message stringlengths 2 65.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 0 108k | cluster float64 14 14 | __index_level_0__ int64 0 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice's hair is growing by leaps and bounds. Maybe the cause of it is the excess of vitamins, or maybe it is some black magic...
To prevent this, Alice decided to go to the hairdresser. She wants for her hair length to be at most l centimeters after haircut, where l is her favorite number. Suppose, that the Alice's head is a straight line on which n hairlines grow. Let's number them from 1 to n. With one swing of the scissors the hairdresser can shorten all hairlines on any segment to the length l, given that all hairlines on that segment had length strictly greater than l. The hairdresser wants to complete his job as fast as possible, so he will make the least possible number of swings of scissors, since each swing of scissors takes one second.
Alice hasn't decided yet when she would go to the hairdresser, so she asked you to calculate how much time the haircut would take depending on the time she would go to the hairdresser. In particular, you need to process queries of two types:
* 0 — Alice asks how much time the haircut would take if she would go to the hairdresser now.
* 1 p d — p-th hairline grows by d centimeters.
Note, that in the request 0 Alice is interested in hypothetical scenario of taking a haircut now, so no hairlines change their length.
Input
The first line contains three integers n, m and l (1 ≤ n, m ≤ 100 000, 1 ≤ l ≤ 10^9) — the number of hairlines, the number of requests and the favorite number of Alice.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^9) — the initial lengths of all hairlines of Alice.
Each of the following m lines contains a request in the format described in the statement.
The request description starts with an integer t_i. If t_i = 0, then you need to find the time the haircut would take. Otherwise, t_i = 1 and in this moment one hairline grows. The rest of the line than contains two more integers: p_i and d_i (1 ≤ p_i ≤ n, 1 ≤ d_i ≤ 10^9) — the number of the hairline and the length it grows by.
Output
For each query of type 0 print the time the haircut would take.
Example
Input
4 7 3
1 2 3 4
0
1 2 3
0
1 1 3
0
1 3 1
0
Output
1
2
2
1
Note
Consider the first example:
* Initially lengths of hairlines are equal to 1, 2, 3, 4 and only 4-th hairline is longer l=3, and hairdresser can cut it in 1 second.
* Then Alice's second hairline grows, the lengths of hairlines are now equal to 1, 5, 3, 4
* Now haircut takes two seonds: two swings are required: for the 4-th hairline and for the 2-nd.
* Then Alice's first hairline grows, the lengths of hairlines are now equal to 4, 5, 3, 4
* The haircut still takes two seconds: with one swing hairdresser can cut 4-th hairline and with one more swing cut the segment from 1-st to 2-nd hairline.
* Then Alice's third hairline grows, the lengths of hairlines are now equal to 4, 5, 4, 4
* Now haircut takes only one second: with one swing it is possible to cut the segment from 1-st hairline to the 4-th.
Submitted Solution:
```
# k, hairs = grow_hair(k, hairs, l, hair_index, add_to_hair)
def grow_hair(k, hairs, length, hair_index, add_to_hair):
old_hair_length = hairs[hair_index]
hairs[hair_index] = hairs[hair_index] + add_to_hair
if old_hair_length <= length < hairs[hair_index]:
if 0 < hair_index < len(hairs)-1 and hairs[hair_index - 1] > length \
and hairs[hair_index + 1] > length:
k -= 1
elif (hair_index == 0 or hairs[hair_index - 1] <= length) \
and (len(hairs)-1 == hair_index or hairs[hair_index + 1] <= length):
k += 1
return k, hairs
def count_k(hairs, l):
k = 0
for i in range(len(hairs)):
if i == 0:
if hairs[i] > l:
k += 1
else:
if hairs[i] > l:
if hairs[i-1] <= l:
k += 1
return k
def count_barber_work():
n, m, l = map(int, input().split())
'''
количество волос,
количество запросов,
любимое число Алисы (любимая длинна волоса)
'''
hairs = list(map(int, input().split()))
k = count_k(hairs, l)
for _ in range(m):
i = input()
if i == '0':
print(k)
else:
_, hair_index, add_to_hair = map(int, i.split())
k, hairs = grow_hair(k, hairs, l, hair_index-1, add_to_hair)
# def count_barber_work(log):
# n, m, l = map(int, log[0].split())
# '''
# количество волос,
# количество запросов,
# любимое число Алисы (любимая длина волоса)
# '''
# hairs = list(map(int, log[1].split()))
# k = count_k(hairs, l)
# for i in log[2:]:
# if i == '0':
# print(k)
# else:
# _, hair_index, add_to_hair = map(int, i.split())
# print(hairs)
# k, hairs = grow_hair(k, hairs, l, hair_index-1, add_to_hair)
# print(hairs)
count_barber_work()
# if __name__ == '__main__':
# test = ['4 7 3',
# '1 2 3 4',
# '0',
# '1 2 3',
# '0',
# '1 1 3',
# '0',
# '1 3 1',
# '0']
# test = ['3 3 1',
# '1 1 3',
# '0',
# '1 1 3',
# '0']
# count_barber_work(test)
``` | instruction | 0 | 24,772 | 14 | 49,544 |
Yes | output | 1 | 24,772 | 14 | 49,545 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice's hair is growing by leaps and bounds. Maybe the cause of it is the excess of vitamins, or maybe it is some black magic...
To prevent this, Alice decided to go to the hairdresser. She wants for her hair length to be at most l centimeters after haircut, where l is her favorite number. Suppose, that the Alice's head is a straight line on which n hairlines grow. Let's number them from 1 to n. With one swing of the scissors the hairdresser can shorten all hairlines on any segment to the length l, given that all hairlines on that segment had length strictly greater than l. The hairdresser wants to complete his job as fast as possible, so he will make the least possible number of swings of scissors, since each swing of scissors takes one second.
Alice hasn't decided yet when she would go to the hairdresser, so she asked you to calculate how much time the haircut would take depending on the time she would go to the hairdresser. In particular, you need to process queries of two types:
* 0 — Alice asks how much time the haircut would take if she would go to the hairdresser now.
* 1 p d — p-th hairline grows by d centimeters.
Note, that in the request 0 Alice is interested in hypothetical scenario of taking a haircut now, so no hairlines change their length.
Input
The first line contains three integers n, m and l (1 ≤ n, m ≤ 100 000, 1 ≤ l ≤ 10^9) — the number of hairlines, the number of requests and the favorite number of Alice.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^9) — the initial lengths of all hairlines of Alice.
Each of the following m lines contains a request in the format described in the statement.
The request description starts with an integer t_i. If t_i = 0, then you need to find the time the haircut would take. Otherwise, t_i = 1 and in this moment one hairline grows. The rest of the line than contains two more integers: p_i and d_i (1 ≤ p_i ≤ n, 1 ≤ d_i ≤ 10^9) — the number of the hairline and the length it grows by.
Output
For each query of type 0 print the time the haircut would take.
Example
Input
4 7 3
1 2 3 4
0
1 2 3
0
1 1 3
0
1 3 1
0
Output
1
2
2
1
Note
Consider the first example:
* Initially lengths of hairlines are equal to 1, 2, 3, 4 and only 4-th hairline is longer l=3, and hairdresser can cut it in 1 second.
* Then Alice's second hairline grows, the lengths of hairlines are now equal to 1, 5, 3, 4
* Now haircut takes two seonds: two swings are required: for the 4-th hairline and for the 2-nd.
* Then Alice's first hairline grows, the lengths of hairlines are now equal to 4, 5, 3, 4
* The haircut still takes two seconds: with one swing hairdresser can cut 4-th hairline and with one more swing cut the segment from 1-st to 2-nd hairline.
* Then Alice's third hairline grows, the lengths of hairlines are now equal to 4, 5, 4, 4
* Now haircut takes only one second: with one swing it is possible to cut the segment from 1-st hairline to the 4-th.
Submitted Solution:
```
from sys import stdin, stdout
input, print = stdin.readline, stdout.write
def main(input=input, print=print, map=map, int=int, range=range, sum=sum, str=str, list=list):
n, m, k = map(int, input().split())
a = [-1] + list(map(int, input().split())) + [-1]
ans = sum(a[q] <= k < a[q + 1] for q in range(n + 1))
answer = []
for _ in range(m):
d = list(map(int, input().split()))
if d[0] == 0:
answer.append(str(ans))
else:
q, x = d[1], d[2]
ans += (a[q - 1] <= k and a[q + 1] <= k and a[q] + x > k >= a[q]) - (
a[q - 1] > k and a[q + 1] > k and a[q] + x > k >= a[q])
a[q] += x
print('\n'.join(answer))
main()
``` | instruction | 0 | 24,773 | 14 | 49,546 |
Yes | output | 1 | 24,773 | 14 | 49,547 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice's hair is growing by leaps and bounds. Maybe the cause of it is the excess of vitamins, or maybe it is some black magic...
To prevent this, Alice decided to go to the hairdresser. She wants for her hair length to be at most l centimeters after haircut, where l is her favorite number. Suppose, that the Alice's head is a straight line on which n hairlines grow. Let's number them from 1 to n. With one swing of the scissors the hairdresser can shorten all hairlines on any segment to the length l, given that all hairlines on that segment had length strictly greater than l. The hairdresser wants to complete his job as fast as possible, so he will make the least possible number of swings of scissors, since each swing of scissors takes one second.
Alice hasn't decided yet when she would go to the hairdresser, so she asked you to calculate how much time the haircut would take depending on the time she would go to the hairdresser. In particular, you need to process queries of two types:
* 0 — Alice asks how much time the haircut would take if she would go to the hairdresser now.
* 1 p d — p-th hairline grows by d centimeters.
Note, that in the request 0 Alice is interested in hypothetical scenario of taking a haircut now, so no hairlines change their length.
Input
The first line contains three integers n, m and l (1 ≤ n, m ≤ 100 000, 1 ≤ l ≤ 10^9) — the number of hairlines, the number of requests and the favorite number of Alice.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^9) — the initial lengths of all hairlines of Alice.
Each of the following m lines contains a request in the format described in the statement.
The request description starts with an integer t_i. If t_i = 0, then you need to find the time the haircut would take. Otherwise, t_i = 1 and in this moment one hairline grows. The rest of the line than contains two more integers: p_i and d_i (1 ≤ p_i ≤ n, 1 ≤ d_i ≤ 10^9) — the number of the hairline and the length it grows by.
Output
For each query of type 0 print the time the haircut would take.
Example
Input
4 7 3
1 2 3 4
0
1 2 3
0
1 1 3
0
1 3 1
0
Output
1
2
2
1
Note
Consider the first example:
* Initially lengths of hairlines are equal to 1, 2, 3, 4 and only 4-th hairline is longer l=3, and hairdresser can cut it in 1 second.
* Then Alice's second hairline grows, the lengths of hairlines are now equal to 1, 5, 3, 4
* Now haircut takes two seonds: two swings are required: for the 4-th hairline and for the 2-nd.
* Then Alice's first hairline grows, the lengths of hairlines are now equal to 4, 5, 3, 4
* The haircut still takes two seconds: with one swing hairdresser can cut 4-th hairline and with one more swing cut the segment from 1-st to 2-nd hairline.
* Then Alice's third hairline grows, the lengths of hairlines are now equal to 4, 5, 4, 4
* Now haircut takes only one second: with one swing it is possible to cut the segment from 1-st hairline to the 4-th.
Submitted Solution:
```
from sys import stdin, stdout
input, print = stdin.readline, stdout.write
def main(input=input, print=print, map=map, int=int, range=range, str=str, list=list):
n, m, l = map(int, input().split())
a = [-1]+list(map(int, input().split()))+[-1]
x = sum(1 for q in range(n+1) if a[q] > l >= a[q-1])
answer = []
for _ in range(m):
s = list(map(int, input().split()))
if s[0] == 0:
answer.append(str(x))
else:
w = s[1]
f, f1 = a[w-1] <= l, a[w+1] <= l
if a[w]+s[2] > l >= a[w]:
x += (f and f1)-(not (f or f1))
a[w] += s[2]
print('\n'.join(answer))
main()
``` | instruction | 0 | 24,774 | 14 | 49,548 |
Yes | output | 1 | 24,774 | 14 | 49,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice's hair is growing by leaps and bounds. Maybe the cause of it is the excess of vitamins, or maybe it is some black magic...
To prevent this, Alice decided to go to the hairdresser. She wants for her hair length to be at most l centimeters after haircut, where l is her favorite number. Suppose, that the Alice's head is a straight line on which n hairlines grow. Let's number them from 1 to n. With one swing of the scissors the hairdresser can shorten all hairlines on any segment to the length l, given that all hairlines on that segment had length strictly greater than l. The hairdresser wants to complete his job as fast as possible, so he will make the least possible number of swings of scissors, since each swing of scissors takes one second.
Alice hasn't decided yet when she would go to the hairdresser, so she asked you to calculate how much time the haircut would take depending on the time she would go to the hairdresser. In particular, you need to process queries of two types:
* 0 — Alice asks how much time the haircut would take if she would go to the hairdresser now.
* 1 p d — p-th hairline grows by d centimeters.
Note, that in the request 0 Alice is interested in hypothetical scenario of taking a haircut now, so no hairlines change their length.
Input
The first line contains three integers n, m and l (1 ≤ n, m ≤ 100 000, 1 ≤ l ≤ 10^9) — the number of hairlines, the number of requests and the favorite number of Alice.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^9) — the initial lengths of all hairlines of Alice.
Each of the following m lines contains a request in the format described in the statement.
The request description starts with an integer t_i. If t_i = 0, then you need to find the time the haircut would take. Otherwise, t_i = 1 and in this moment one hairline grows. The rest of the line than contains two more integers: p_i and d_i (1 ≤ p_i ≤ n, 1 ≤ d_i ≤ 10^9) — the number of the hairline and the length it grows by.
Output
For each query of type 0 print the time the haircut would take.
Example
Input
4 7 3
1 2 3 4
0
1 2 3
0
1 1 3
0
1 3 1
0
Output
1
2
2
1
Note
Consider the first example:
* Initially lengths of hairlines are equal to 1, 2, 3, 4 and only 4-th hairline is longer l=3, and hairdresser can cut it in 1 second.
* Then Alice's second hairline grows, the lengths of hairlines are now equal to 1, 5, 3, 4
* Now haircut takes two seonds: two swings are required: for the 4-th hairline and for the 2-nd.
* Then Alice's first hairline grows, the lengths of hairlines are now equal to 4, 5, 3, 4
* The haircut still takes two seconds: with one swing hairdresser can cut 4-th hairline and with one more swing cut the segment from 1-st to 2-nd hairline.
* Then Alice's third hairline grows, the lengths of hairlines are now equal to 4, 5, 4, 4
* Now haircut takes only one second: with one swing it is possible to cut the segment from 1-st hairline to the 4-th.
Submitted Solution:
```
n, m, l = map(int, input().split())
a = list(map(int, input().split()))
nexxt = {}
prevv = {}
nexxt[-1] = n
prevv[n] = -1
summ = 0
p = -1
l += 1
for k in range(n):
if a[k] < l:
p1 = p
p = k
nexxt[k] = n
prevv[k] = p1
nexxt[p1] = k
if k - prevv[k] > 1:
summ += (k - prevv[k] - 2) // l + 1
prevv[n] = p
if n - p > 1:
summ += (n - p - 2) // l + 1
for i in range(m):
s = input()
if s == '0':
print(summ)
else:
_, p, d = map(int, s.split())
if nexxt[-1] == n:
continue
if a[p - 1] < l:
a[p-1] += d
if a[p-1] >=l:
k = p-1
left = prevv[k]
right = nexxt[k]
nexxt[left] = right
prevv[right] = left
if k - prevv[k] > 1:
summ = summ - (k - prevv[k] - 2) // l - 1
if nexxt[k] - k > 1:
summ = summ - (nexxt[k] - k - 2) // l - 1
summ = summ + (nexxt[k] - prevv[k] - 2) // l + 1
``` | instruction | 0 | 24,775 | 14 | 49,550 |
No | output | 1 | 24,775 | 14 | 49,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice's hair is growing by leaps and bounds. Maybe the cause of it is the excess of vitamins, or maybe it is some black magic...
To prevent this, Alice decided to go to the hairdresser. She wants for her hair length to be at most l centimeters after haircut, where l is her favorite number. Suppose, that the Alice's head is a straight line on which n hairlines grow. Let's number them from 1 to n. With one swing of the scissors the hairdresser can shorten all hairlines on any segment to the length l, given that all hairlines on that segment had length strictly greater than l. The hairdresser wants to complete his job as fast as possible, so he will make the least possible number of swings of scissors, since each swing of scissors takes one second.
Alice hasn't decided yet when she would go to the hairdresser, so she asked you to calculate how much time the haircut would take depending on the time she would go to the hairdresser. In particular, you need to process queries of two types:
* 0 — Alice asks how much time the haircut would take if she would go to the hairdresser now.
* 1 p d — p-th hairline grows by d centimeters.
Note, that in the request 0 Alice is interested in hypothetical scenario of taking a haircut now, so no hairlines change their length.
Input
The first line contains three integers n, m and l (1 ≤ n, m ≤ 100 000, 1 ≤ l ≤ 10^9) — the number of hairlines, the number of requests and the favorite number of Alice.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^9) — the initial lengths of all hairlines of Alice.
Each of the following m lines contains a request in the format described in the statement.
The request description starts with an integer t_i. If t_i = 0, then you need to find the time the haircut would take. Otherwise, t_i = 1 and in this moment one hairline grows. The rest of the line than contains two more integers: p_i and d_i (1 ≤ p_i ≤ n, 1 ≤ d_i ≤ 10^9) — the number of the hairline and the length it grows by.
Output
For each query of type 0 print the time the haircut would take.
Example
Input
4 7 3
1 2 3 4
0
1 2 3
0
1 1 3
0
1 3 1
0
Output
1
2
2
1
Note
Consider the first example:
* Initially lengths of hairlines are equal to 1, 2, 3, 4 and only 4-th hairline is longer l=3, and hairdresser can cut it in 1 second.
* Then Alice's second hairline grows, the lengths of hairlines are now equal to 1, 5, 3, 4
* Now haircut takes two seonds: two swings are required: for the 4-th hairline and for the 2-nd.
* Then Alice's first hairline grows, the lengths of hairlines are now equal to 4, 5, 3, 4
* The haircut still takes two seconds: with one swing hairdresser can cut 4-th hairline and with one more swing cut the segment from 1-st to 2-nd hairline.
* Then Alice's third hairline grows, the lengths of hairlines are now equal to 4, 5, 4, 4
* Now haircut takes only one second: with one swing it is possible to cut the segment from 1-st hairline to the 4-th.
Submitted Solution:
```
#!/usr/bin/env python3
import sys
def count_it():
return len(''.join(list(map(lambda x: ' ' if x <= l else '1', h))).split())
n, m, l = list(map(lambda x: int(x), sys.stdin.readline().split(' ')))
h = list(map(lambda x: int(x), sys.stdin.readline().split(' ')))
for mi in range(m):
request = sys.stdin.readline().split(' ')
if len(request) == 1:
count_it()
else:
r, p, d = list(map(lambda x: int(x), request))
h[p - 1] += d
# k = count_it()
# for mi in range(m):
# request = sys.stdin.readline().split(' ')
# if len(request) == 1:
# print(count_it())
# else:
# r, p, d = list(map(lambda x: int(x), request))
# h[p - 1] += d
# if h[p - 1] > l and h[p - 1] - d <= l:
# if (p - 1 == 0 and h[1] <= l) or (p == len(h) and h[p - 2] <= l) or (h[p - 2] <= l and h[p] <= l):
# k += 1
# elif p - 1 != 0 and p != len(h) and h[p - 2] > l and h[p] > l:
# k -= 1
``` | instruction | 0 | 24,776 | 14 | 49,552 |
No | output | 1 | 24,776 | 14 | 49,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice's hair is growing by leaps and bounds. Maybe the cause of it is the excess of vitamins, or maybe it is some black magic...
To prevent this, Alice decided to go to the hairdresser. She wants for her hair length to be at most l centimeters after haircut, where l is her favorite number. Suppose, that the Alice's head is a straight line on which n hairlines grow. Let's number them from 1 to n. With one swing of the scissors the hairdresser can shorten all hairlines on any segment to the length l, given that all hairlines on that segment had length strictly greater than l. The hairdresser wants to complete his job as fast as possible, so he will make the least possible number of swings of scissors, since each swing of scissors takes one second.
Alice hasn't decided yet when she would go to the hairdresser, so she asked you to calculate how much time the haircut would take depending on the time she would go to the hairdresser. In particular, you need to process queries of two types:
* 0 — Alice asks how much time the haircut would take if she would go to the hairdresser now.
* 1 p d — p-th hairline grows by d centimeters.
Note, that in the request 0 Alice is interested in hypothetical scenario of taking a haircut now, so no hairlines change their length.
Input
The first line contains three integers n, m and l (1 ≤ n, m ≤ 100 000, 1 ≤ l ≤ 10^9) — the number of hairlines, the number of requests and the favorite number of Alice.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^9) — the initial lengths of all hairlines of Alice.
Each of the following m lines contains a request in the format described in the statement.
The request description starts with an integer t_i. If t_i = 0, then you need to find the time the haircut would take. Otherwise, t_i = 1 and in this moment one hairline grows. The rest of the line than contains two more integers: p_i and d_i (1 ≤ p_i ≤ n, 1 ≤ d_i ≤ 10^9) — the number of the hairline and the length it grows by.
Output
For each query of type 0 print the time the haircut would take.
Example
Input
4 7 3
1 2 3 4
0
1 2 3
0
1 1 3
0
1 3 1
0
Output
1
2
2
1
Note
Consider the first example:
* Initially lengths of hairlines are equal to 1, 2, 3, 4 and only 4-th hairline is longer l=3, and hairdresser can cut it in 1 second.
* Then Alice's second hairline grows, the lengths of hairlines are now equal to 1, 5, 3, 4
* Now haircut takes two seonds: two swings are required: for the 4-th hairline and for the 2-nd.
* Then Alice's first hairline grows, the lengths of hairlines are now equal to 4, 5, 3, 4
* The haircut still takes two seconds: with one swing hairdresser can cut 4-th hairline and with one more swing cut the segment from 1-st to 2-nd hairline.
* Then Alice's third hairline grows, the lengths of hairlines are now equal to 4, 5, 4, 4
* Now haircut takes only one second: with one swing it is possible to cut the segment from 1-st hairline to the 4-th.
Submitted Solution:
```
def go():
n, m, l = [int(i) for i in input().split(' ')]
a = [int(i) for i in input().split(' ')]
r = []
o = ''
for i in range(n):
if a[i] > l:
if len(r) and r[-1][1] == i - 1:
r[-1][1] = i
else:
r.append([i, i])
for i in range(m):
x = [int(j) for j in input().split(' ')]
if x[0] == 0:
o += str(len(r)) + '\n'
else:
a[x[1] - 1] += x[2]
if a[x[1] - 1] > l:
found = False
j = 0
while j < len(r) and not found:
if r[j][0] == x[1]:
r[j][0] = x[1] - 1
for k in range(j, len(r)):
if r[k][1] == x[1] - 2:
r[j][0] = r[k][0]
r.pop(k)
found = True
break
elif r[j][1] == x[1] - 2:
r[j][1] = x[1] - 1
for k in range(j, len(r)):
if r[k][0] == x[1]:
r[j][1] = r[k][1]
r.pop(k)
found = True
break
j += 1
else:
r.append([x[1] - 1, x[1] - 1])
return o
print(go())
``` | instruction | 0 | 24,777 | 14 | 49,554 |
No | output | 1 | 24,777 | 14 | 49,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice's hair is growing by leaps and bounds. Maybe the cause of it is the excess of vitamins, or maybe it is some black magic...
To prevent this, Alice decided to go to the hairdresser. She wants for her hair length to be at most l centimeters after haircut, where l is her favorite number. Suppose, that the Alice's head is a straight line on which n hairlines grow. Let's number them from 1 to n. With one swing of the scissors the hairdresser can shorten all hairlines on any segment to the length l, given that all hairlines on that segment had length strictly greater than l. The hairdresser wants to complete his job as fast as possible, so he will make the least possible number of swings of scissors, since each swing of scissors takes one second.
Alice hasn't decided yet when she would go to the hairdresser, so she asked you to calculate how much time the haircut would take depending on the time she would go to the hairdresser. In particular, you need to process queries of two types:
* 0 — Alice asks how much time the haircut would take if she would go to the hairdresser now.
* 1 p d — p-th hairline grows by d centimeters.
Note, that in the request 0 Alice is interested in hypothetical scenario of taking a haircut now, so no hairlines change their length.
Input
The first line contains three integers n, m and l (1 ≤ n, m ≤ 100 000, 1 ≤ l ≤ 10^9) — the number of hairlines, the number of requests and the favorite number of Alice.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^9) — the initial lengths of all hairlines of Alice.
Each of the following m lines contains a request in the format described in the statement.
The request description starts with an integer t_i. If t_i = 0, then you need to find the time the haircut would take. Otherwise, t_i = 1 and in this moment one hairline grows. The rest of the line than contains two more integers: p_i and d_i (1 ≤ p_i ≤ n, 1 ≤ d_i ≤ 10^9) — the number of the hairline and the length it grows by.
Output
For each query of type 0 print the time the haircut would take.
Example
Input
4 7 3
1 2 3 4
0
1 2 3
0
1 1 3
0
1 3 1
0
Output
1
2
2
1
Note
Consider the first example:
* Initially lengths of hairlines are equal to 1, 2, 3, 4 and only 4-th hairline is longer l=3, and hairdresser can cut it in 1 second.
* Then Alice's second hairline grows, the lengths of hairlines are now equal to 1, 5, 3, 4
* Now haircut takes two seonds: two swings are required: for the 4-th hairline and for the 2-nd.
* Then Alice's first hairline grows, the lengths of hairlines are now equal to 4, 5, 3, 4
* The haircut still takes two seconds: with one swing hairdresser can cut 4-th hairline and with one more swing cut the segment from 1-st to 2-nd hairline.
* Then Alice's third hairline grows, the lengths of hairlines are now equal to 4, 5, 4, 4
* Now haircut takes only one second: with one swing it is possible to cut the segment from 1-st hairline to the 4-th.
Submitted Solution:
```
N,m,l=[int(s) for s in input().split()]
a=[int(s) for s in input().split()]
i=0
n=None
k=None
d=[]
while i<N:
if a[i]>l:
if n is None:
n=i
k=i
else:
k=i
else:
if not n is None:
d.append([n,k])
n=None
k=None
i+=1
if not n is None :
d.append([n,k])
for j in range(m):
h=[int(s) for s in input().split()]
#print(d)
if h[0]==0:
print(len(d))
else:
h[1]-=1
a[h[1]]+=h[2]
if a[h[1]]>l:
for i in range(len(d)):
if d[i][0]>=h[1]:
if d[i][0]==h[1]:
ok=1
elif d[i][0]==h[1]+1:
d[i][0]=h[1]
if i>0 and d[i-1][1]-d[i][0]<1:
d[i-1][1]=d[i][0]
del d[i]
elif i>0 and abs(h[1]-d[i-1][1])<=1:
d[i-1][1]=h[1]
else:
d.insert(i,[h[1],h[1]])
break
else:
d.append([h,h])
#print(d)
``` | instruction | 0 | 24,778 | 14 | 49,556 |
No | output | 1 | 24,778 | 14 | 49,557 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests. | instruction | 0 | 25,048 | 14 | 50,096 |
Tags: greedy
Correct Solution:
```
from collections import defaultdict
ag=defaultdict(int)
for i in input():
if i=='9':ag['6']+=1
elif i=='5':ag['2']+=1
else:ag[i]+=1
g=defaultdict(int)
for i in input():
if i=='9':g['6']+=1
elif i=='5':g['2']+=1
else:g[i]+=1
ans=999999999999999999
for i in ag:
ans=min(ans,g[i]//ag[i])
print(ans)
``` | output | 1 | 25,048 | 14 | 50,097 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests. | instruction | 0 | 25,049 | 14 | 50,098 |
Tags: greedy
Correct Solution:
```
favornumb={'0':0, '1':0, '2':0,
'3':0, '4':0, '6':0,
'7':0, '8':0}
mass={'0':0, '1':0, '2':0,
'3':0, '4':0, '6':0,
'7':0, '8':0}
for i in input():
if i=='2' or i=='5': favornumb['2']+=1
elif i=='6' or i=='9': favornumb['6']+=1
else: favornumb[i]+=1
for i in input():
if i=='2' or i=='5': mass['2']+=1
elif i=='6' or i=='9': mass['6']+=1
else: mass[i]+=1
ans=200
for i in ['0', '1', '2', '3', '4', '6', '7', '8']:
if favornumb[i]==0: continue
else:
pretend=int(mass[i]/favornumb[i])
if pretend<=ans: ans=pretend
print(ans)
``` | output | 1 | 25,049 | 14 | 50,099 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests. | instruction | 0 | 25,050 | 14 | 50,100 |
Tags: greedy
Correct Solution:
```
def c(a, b):
a = a.replace('6', '9')
a = a.replace('2', '5')
b = b.replace('6', '9')
b = b.replace('2', '5')
n = 10000
for i in '01345789':
t = a.count(i)
if t != 0:
n = min(n, b.count(i)//t)
return n
a = input()
b = input()
print(c(a, b))
``` | output | 1 | 25,050 | 14 | 50,101 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests. | instruction | 0 | 25,051 | 14 | 50,102 |
Tags: greedy
Correct Solution:
```
a = input()
b = input()
d = {}
for e in b:
if e == '9':
e = '6'
if e == '5':
e = '2'
if e in d:
d[e] = d[e] + 1
else:
d[e] = 1
n = {}
for e in a:
if e == '9':
e = '6'
if e == '5':
e = '2'
if e in n:
n[e] += 1
else:
n[e] = 1
result = 10000000
for e in n:
if e not in d:
result = 0
break
else:
temp_result = int(d[e] / n[e])
if temp_result < result:
result = temp_result
print(result)
``` | output | 1 | 25,051 | 14 | 50,103 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests. | instruction | 0 | 25,053 | 14 | 50,106 |
Tags: greedy
Correct Solution:
```
req_arr = [int(x) for x in input().strip()]
arr = [int(x) for x in input().strip()]
required_list = [0]*10
num_list = [0]*10
for i in req_arr:
if i == 5:
required_list[2] += 1
elif i == 9:
required_list[6] += 1
else:
required_list[i] += 1
for i in arr:
if i == 5:
num_list[2] += 1
elif i == 9:
num_list[6] += 1
else:
num_list[i] += 1
ans = len(arr)
for i, j in enumerate(required_list):
if j > 0:
ans = min(ans, int(num_list[i]/j))
print(ans)
``` | output | 1 | 25,053 | 14 | 50,107 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests. | instruction | 0 | 25,054 | 14 | 50,108 |
Tags: greedy
Correct Solution:
```
t = int(input())
s = input()
q = {'0': 0, '1': 0, '2': 0, '3': 0, '4': 0, '6': 0, '7': 0, '8': 0}
for d in s:
if d == '5':
q['2'] += 1
elif d == '9':
q['6'] += 1
else:
q[d] += 1
p = {'0': 0, '1': 0, '2': 0, '3': 0, '4': 0, '6': 0, '7': 0, '8': 0}
while t != 0:
d = str(t % 10)
if d == '5':
p['2'] += 1
elif d == '9':
p['6'] += 1
else:
p[d] += 1
t //= 10
c = len(s)
for d in p.keys():
if p[d] != 0:
c = min(c, q[d] // p[d])
print(c)
``` | output | 1 | 25,054 | 14 | 50,109 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests. | instruction | 0 | 25,055 | 14 | 50,110 |
Tags: greedy
Correct Solution:
```
t = input().replace('5', '2').replace('9', '6')
s = input().replace('5', '2').replace('9', '6')
res = 10 ** 100
for i in t:
res = min(res, s.count(i) // t.count(i))
print(res)
# Made By Mostafa_Khaled
``` | output | 1 | 25,055 | 14 | 50,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests.
Submitted Solution:
```
def convert_string(string_list,len_string_list):
change_dict={}
change_dict['9']='6'
change_dict['5']='2'
for i in range(len_string_list):
if string_list[i] in change_dict:
string_list[i]=change_dict[string_list[i]]
#print(string_list)
def form_frequency_dict(given_list):
freq_dict={}
for i in given_list:
if i in freq_dict:
freq_dict[i]+=1
else:
freq_dict[i]=1
return freq_dict
def find_max_repititions(required_string_freq_dict,given_string_freq_dict):
max_repititions=201
for key,value in required_string_freq_dict.items():
if key in given_string_freq_dict:
max_repititions_now_possible=given_string_freq_dict[key]//required_string_freq_dict[key]
if(max_repititions_now_possible<max_repititions):
max_repititions=max_repititions_now_possible
if max_repititions==201:
max_repititions=0
return max_repititions
import sys
inputlist=sys.stdin.readlines()
required_string=list(inputlist[0].strip())
given_string=list(inputlist[1].strip())
#print(required_string,given_string)
len_required_string=len(required_string)
len_given_string=len(given_string)
convert_string(required_string,len_required_string)
convert_string(given_string,len_given_string)
#print(required_string,given_string)
required_string_freq_dict=form_frequency_dict(required_string)
given_string_freq_dict=form_frequency_dict(given_string)
max_repititions=find_max_repititions(required_string_freq_dict,given_string_freq_dict)
print(max_repititions)
``` | instruction | 0 | 25,057 | 14 | 50,114 |
Yes | output | 1 | 25,057 | 14 | 50,115 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests.
Submitted Solution:
```
t = map(int, input().strip())
s = map(int, input().strip())
digits1 = [0] * 10 # makes a list of size 10 filled with zeros.
digits2 = [0] * 10
for i in t:
digits1[i] += 1
digits1[2] += digits1[5]
digits1[6] += digits1[9]
digits1[5] = digits1[9] = 0
for i in s:
digits2[i] += 1
digits2[2] += digits2[5]
digits2[6] += digits2[9]
digits2[5] = digits2[9] = 0
print(min(map(lambda x : digits2[x] // digits1[x] if digits1[x] != 0 else 999999, range(10))))
``` | instruction | 0 | 25,058 | 14 | 50,116 |
Yes | output | 1 | 25,058 | 14 | 50,117 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests.
Submitted Solution:
```
t=[*map(int,input())]
s=[*map(int,input())]
d={0:0,1:0,2:0,3:0,4:0,6:0,7:0,8:0}
di={0:0,1:0,2:0,3:0,4:0,6:0,7:0,8:0}
for i,x in enumerate(t):
if x==6 or x==9:d[6]+=1
elif x==2 or x==5:d[2]+=1
else:d[x]+=1
for i,x in enumerate(s):
if x==6 or x==9:di[6]+=1
elif x==2 or x==5:di[2]+=1
else:di[x]+=1
res=10000000000000000000000000
for i,x in enumerate(d):
if d[x]>0:
res=min(res,di[x]//d[x])
print(res)
``` | instruction | 0 | 25,059 | 14 | 50,118 |
Yes | output | 1 | 25,059 | 14 | 50,119 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests.
Submitted Solution:
```
def factorial(n):
p = 1
for i in range(2,n+1):
p *= i
return p
def get_permutatuions(a,b,c,d):
if (c+d)<(a+b):
return 0
return int(factorial(c+d)/(factorial(c+d-a-b)*factorial(c)*factorial(d)))
def get_dict(s):
n2,n5,n6,n9 = 0,0,0,0
for i in s:
if i=='2':
n2 += 1
elif i=='5':
n5 += 1
elif i=='6':
n6 += 1
elif i=='9':
n9 += 1
return (n2,n5,n6,n9)
def main():
n = input()
m = input()
nd = get_dict(n)
md = get_dict(m)
print(get_permutatuions(*nd[:2], *md[:2])*get_permutatuions(*nd[2:],*md[2:]))
if __name__=='__main__':
main()
``` | instruction | 0 | 25,060 | 14 | 50,120 |
No | output | 1 | 25,060 | 14 | 50,121 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests.
Submitted Solution:
```
def factorial(n):
p = 1
for i in range(2,n+1):
p *= i
return p
def get_permutatuions(a,b,c,d):
if (a+b)>(c+d):
return 0
return int(factorial(c+d)/(factorial(c+d-a-b)*factorial(c)*factorial(d)))
def is_valid(n,m):
for i in range(10):
if i==2 or i==5 or i==6 or i==9:
continue
if n[i]>m[i]:
return False
return True
def get_list(s):
l = [0 for i in range(10)]
for i in s:
l[ord(i)-48] += 1
return l
def main():
n = input()
m = input()
nd = get_list(n)
md = get_list(m)
if is_valid(nd, md):
print(get_permutatuions(nd[2],nd[5],md[2],md[5])*get_permutatuions(nd[6],nd[9],md[6],md[9]))
else:
print(0)
if __name__=='__main__':
main()
``` | instruction | 0 | 25,062 | 14 | 50,124 |
No | output | 1 | 25,062 | 14 | 50,125 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Do you remember how Kai constructed the word "eternity" using pieces of ice as components?
Little Sheldon plays with pieces of ice, each piece has exactly one digit between 0 and 9. He wants to construct his favourite number t. He realized that digits 6 and 9 are very similar, so he can rotate piece of ice with 6 to use as 9 (and vice versa). Similary, 2 and 5 work the same. There is no other pair of digits with similar effect. He called this effect "Digital Mimicry".
Sheldon favourite number is t. He wants to have as many instances of t as possible. How many instances he can construct using the given sequence of ice pieces. He can use any piece at most once.
Input
The first line contains integer t (1 ≤ t ≤ 10000). The second line contains the sequence of digits on the pieces. The length of line is equal to the number of pieces and between 1 and 200, inclusive. It contains digits between 0 and 9.
Output
Print the required number of instances.
Examples
Input
42
23454
Output
2
Input
169
12118999
Output
1
Note
This problem contains very weak pretests.
Submitted Solution:
```
def c(a, b):
n = 10000
for i in '0123456789':
t = a.count(i)
if t != 0:
n = min(n, b.count(i)//t)
return n
a = input()
b = input()
print(c(a, b))
``` | instruction | 0 | 25,063 | 14 | 50,126 |
No | output | 1 | 25,063 | 14 | 50,127 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999 | instruction | 0 | 25,535 | 14 | 51,070 |
"Correct Solution:
```
n, m = map(int, input().split())
li = list(map(int, input().split()))
print(max(li[0]-1, n-li[-1], *[(li[i]-li[i-1])//2 for i in range(1,m)]))
``` | output | 1 | 25,535 | 14 | 51,071 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999 | instruction | 0 | 25,536 | 14 | 51,072 |
"Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def solve(n, received):
not_relayed = received.copy()
for t in range(n + 1):
if len(received) >= n:
return t
new_not_relayed = set()
for person in not_relayed:
if person >= 1:
if (person - 1) not in received:
received.add(person - 1)
new_not_relayed.add(person - 1)
if person <= n - 2:
if (person + 1) not in received:
received.add(person + 1)
new_not_relayed.add(person + 1)
not_relayed = new_not_relayed
def main():
n, m = map(int, input().split())
received_people = set(map(lambda x: int(x) - 1, input().split()))
print(solve(n, received_people.copy()))
if __name__ == '__main__':
main()
``` | output | 1 | 25,536 | 14 | 51,073 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999 | instruction | 0 | 25,537 | 14 | 51,074 |
"Correct Solution:
```
# AOJ 1574: Gossip
# Python3 2018.7.13 bal4u
n, m = map(int, input().split())
a = list(map(int, input().split()))
pre = a[0]; d = 0
for x in a[1:]:
d = max(d, x-pre)
pre = x
print(max(n-pre, max(d>>1, a[0]-1)))
``` | output | 1 | 25,537 | 14 | 51,075 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999 | instruction | 0 | 25,538 | 14 | 51,076 |
"Correct Solution:
```
n,m=map(int,input().split(" "))
a=list(map(int,input().split(" ")))
print(max(a[0]-1,n-a[-1],*[(a[i+1]-a[i])//2 for i in range(m-1)]))
``` | output | 1 | 25,538 | 14 | 51,077 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999 | instruction | 0 | 25,539 | 14 | 51,078 |
"Correct Solution:
```
n,m = map(int,input().split())
a = list(map(int,input().split()))
c = [a[0]-1, n-a[m-1]]
for i in range(m-1):
c.append((a[i+1]-a[i])//2)
print(max(c))
``` | output | 1 | 25,539 | 14 | 51,079 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999 | instruction | 0 | 25,540 | 14 | 51,080 |
"Correct Solution:
```
n, m = map(int, input().split())
a =list(map(int, input().split()))
t = max(a[0] - 1, n - a[-1])
for i in range(1, m):t = max(t, (a[i] - a[i - 1]) // 2)
print(t)
``` | output | 1 | 25,540 | 14 | 51,081 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999 | instruction | 0 | 25,541 | 14 | 51,082 |
"Correct Solution:
```
n, m = map(int, input().split())
lst = [100000 for _ in range(n)]
a_lst = list(map(int, input().split()))
for a in a_lst:
lst[a - 1] = 0
for i in range(n - 1):
lst[i + 1] = min(lst[i] + 1, lst[i + 1])
for i in range(n - 1, 0, -1):
lst[i - 1] = min(lst[i - 1], lst[i] + 1)
print(max(lst))
``` | output | 1 | 25,541 | 14 | 51,083 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999 | instruction | 0 | 25,542 | 14 | 51,084 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
n, m = map(int, input().split())
a = list(map(int, input().split()))
ma = a[0] - 1
for i in range(m-1):
ma = max(ma, (a[i + 1] - a[i]) // 2)
ma = max(ma, n - a[-1])
print(ma)
``` | output | 1 | 25,542 | 14 | 51,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999
Submitted Solution:
```
n, m = map(int, input().split())
a =list(map(int, input().split()))
t = max(a[0] - 1, n - a[-1])
for i in range(1, m):t = max(t, -((a[i - 1] - a[i]) // 2))
print(t)
``` | instruction | 0 | 25,543 | 14 | 51,086 |
No | output | 1 | 25,543 | 14 | 51,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999
Submitted Solution:
```
n, m = map(int, input().split())
a =list(map(int, input().split()))
t = max(a[0] - 1, n - a[-1])
for i in range(1, m):t = max(t, (a[i - 1] - a[i]) // 2)
print(t)
``` | instruction | 0 | 25,544 | 14 | 51,088 |
No | output | 1 | 25,544 | 14 | 51,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem
N idols, numbered from 1 to n in order, are lined up in a row.
Idle i can transmit information to idle i-1 and idle i + 1 in a unit time. However, idol 1 can transmit information only to idol 2, and idol n can transmit information only to idol n-1.
At time 0, m idols with numbers a1, a2, ..., am have secret information. Find the minimum amount of time all idols can get confidential information.
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ m ≤ n
* 1 ≤ ai ≤ n
* All ai values are different
* ai are given in ascending order
Input
The input is given in the following format.
n m
a1 a2 ... am
Two integers n and m are given on the first line, separated by blanks.
On the second line, m integers a1, a2, ..., am are given, separated by blanks.
Output
Outputs the minimum time that information is transmitted to all idles on one line.
Examples
Input
3 2
1 3
Output
1
Input
10 3
2 5 7
Output
3
Input
10 5
2 5 6 8 10
Output
1
Input
100000 1
1
Output
99999
Submitted Solution:
```
n, m = map(int, input().split())
a =[0] + list(map(int, input().split())) + [n]
t = max(a[0] - 1, n - a[-1])
for i in range(1, m):t = max(t, -((a[i - 1] - a[i]) // 2))
print(t)
``` | instruction | 0 | 25,545 | 14 | 51,090 |
No | output | 1 | 25,545 | 14 | 51,091 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Nauuo is a girl who loves random picture websites.
One day she made a random picture website by herself which includes n pictures.
When Nauuo visits the website, she sees exactly one picture. The website does not display each picture with equal probability. The i-th picture has a non-negative weight w_i, and the probability of the i-th picture being displayed is \frac{w_i}{∑_{j=1}^nw_j}. That is to say, the probability of a picture to be displayed is proportional to its weight.
However, Nauuo discovered that some pictures she does not like were displayed too often.
To solve this problem, she came up with a great idea: when she saw a picture she likes, she would add 1 to its weight; otherwise, she would subtract 1 from its weight.
Nauuo will visit the website m times. She wants to know the expected weight of each picture after all the m visits modulo 998244353. Can you help her?
The expected weight of the i-th picture can be denoted by \frac {q_i} {p_i} where \gcd(p_i,q_i)=1, you need to print an integer r_i satisfying 0≤ r_i<998244353 and r_i⋅ p_i≡ q_i\pmod{998244353}. It can be proved that such r_i exists and is unique.
Input
The first line contains two integers n and m (1≤ n≤ 50, 1≤ m≤ 50) — the number of pictures and the number of visits to the website.
The second line contains n integers a_1,a_2,…,a_n (a_i is either 0 or 1) — if a_i=0 , Nauuo does not like the i-th picture; otherwise Nauuo likes the i-th picture. It is guaranteed that there is at least one picture which Nauuo likes.
The third line contains n integers w_1,w_2,…,w_n (1≤ w_i≤50) — the initial weights of the pictures.
Output
The output contains n integers r_1,r_2,…,r_n — the expected weights modulo 998244353.
Examples
Input
2 1
0 1
2 1
Output
332748119
332748119
Input
1 2
1
1
Output
3
Input
3 3
0 1 1
4 3 5
Output
160955686
185138929
974061117
Note
In the first example, if the only visit shows the first picture with a probability of \frac 2 3, the final weights are (1,1); if the only visit shows the second picture with a probability of \frac1 3, the final weights are (2,2).
So, both expected weights are \frac2 3⋅ 1+\frac 1 3⋅ 2=\frac4 3 .
Because 332748119⋅ 3≡ 4\pmod{998244353}, you need to print 332748119 instead of \frac4 3 or 1.3333333333.
In the second example, there is only one picture which Nauuo likes, so every time Nauuo visits the website, w_1 will be increased by 1.
So, the expected weight is 1+2=3.
Nauuo is very naughty so she didn't give you any hint of the third example. | instruction | 0 | 25,645 | 14 | 51,290 |
Tags: dp, probabilities
Correct Solution:
```
P = 998244353
N, M = map(int, input().split())
A = [int(a) for a in input().split()]
B = [int(a) for a in input().split()]
li = sum([A[i]*B[i] for i in range(N)])
di = sum([(A[i]^1)*B[i] for i in range(N)])
X = [1]
SU = li+di
PO = [0] * (5*M+10)
for i in range(-M-5, 2*M+5):
PO[i] = pow((SU+i)%P, P-2, P)
def calc(L):
su = sum(L)
pl = 0
pd = 0
RE = []
for i in range(len(L)):
a = li + i
b = di - (len(L) - 1 - i)
pd = b * L[i] * PO[a+b-SU]
RE.append((pl+pd)%P)
pl = a * L[i] * PO[a+b-SU]
RE.append(pl%P)
return RE
for i in range(M):
X = calc(X)
ne = 0
po = 0
for i in range(M+1):
po = (po + X[i] * (li + i)) % P
ne = (ne + X[i] * (di - M + i)) % P
invli = pow(li, P-2, P)
invdi = pow(di, P-2, P)
for i in range(N):
print(po * B[i] * invli % P if A[i] else ne * B[i] * invdi % P)
``` | output | 1 | 25,645 | 14 | 51,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Nauuo is a girl who loves random picture websites.
One day she made a random picture website by herself which includes n pictures.
When Nauuo visits the website, she sees exactly one picture. The website does not display each picture with equal probability. The i-th picture has a non-negative weight w_i, and the probability of the i-th picture being displayed is \frac{w_i}{∑_{j=1}^nw_j}. That is to say, the probability of a picture to be displayed is proportional to its weight.
However, Nauuo discovered that some pictures she does not like were displayed too often.
To solve this problem, she came up with a great idea: when she saw a picture she likes, she would add 1 to its weight; otherwise, she would subtract 1 from its weight.
Nauuo will visit the website m times. She wants to know the expected weight of each picture after all the m visits modulo 998244353. Can you help her?
The expected weight of the i-th picture can be denoted by \frac {q_i} {p_i} where \gcd(p_i,q_i)=1, you need to print an integer r_i satisfying 0≤ r_i<998244353 and r_i⋅ p_i≡ q_i\pmod{998244353}. It can be proved that such r_i exists and is unique.
Input
The first line contains two integers n and m (1≤ n≤ 50, 1≤ m≤ 50) — the number of pictures and the number of visits to the website.
The second line contains n integers a_1,a_2,…,a_n (a_i is either 0 or 1) — if a_i=0 , Nauuo does not like the i-th picture; otherwise Nauuo likes the i-th picture. It is guaranteed that there is at least one picture which Nauuo likes.
The third line contains n integers w_1,w_2,…,w_n (1≤ w_i≤50) — the initial weights of the pictures.
Output
The output contains n integers r_1,r_2,…,r_n — the expected weights modulo 998244353.
Examples
Input
2 1
0 1
2 1
Output
332748119
332748119
Input
1 2
1
1
Output
3
Input
3 3
0 1 1
4 3 5
Output
160955686
185138929
974061117
Note
In the first example, if the only visit shows the first picture with a probability of \frac 2 3, the final weights are (1,1); if the only visit shows the second picture with a probability of \frac1 3, the final weights are (2,2).
So, both expected weights are \frac2 3⋅ 1+\frac 1 3⋅ 2=\frac4 3 .
Because 332748119⋅ 3≡ 4\pmod{998244353}, you need to print 332748119 instead of \frac4 3 or 1.3333333333.
In the second example, there is only one picture which Nauuo likes, so every time Nauuo visits the website, w_1 will be increased by 1.
So, the expected weight is 1+2=3.
Nauuo is very naughty so she didn't give you any hint of the third example. | instruction | 0 | 25,646 | 14 | 51,292 |
Tags: dp, probabilities
Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def MF(n,d): return ModFraction(n,d)
class ModFraction():
def __init__(self, n, d):
self.n = n
self.d = d
def __add__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.d % mod
b = xf.n * self.d % mod
c = self.d * xf.d % mod
return ModFraction((a+b) % mod, c)
def __sub__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.d % mod
b = -xf.n * self.d % mod
c = self.d * xf.d % mod
return ModFraction((a+b) % mod, c)
def __mul__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.n % mod
b = self.d * xf.d % mod
return ModFraction(a, b)
def __truediv__(self, x):
xf = ModFraction.xf(x)
a = self.n * xf.d % mod
b = self.d * xf.n % mod
return ModFraction(a, b)
@classmethod
def xf(cls, x):
if isinstance(x, int):
return ModFraction(x, 1)
return x
@classmethod
def inv(cls, x):
return pow(x, mod - 2, mod)
def int(self):
return self.n * ModFraction.inv(self.d) % mod
def __str__(self):
return "{} / {}".format(self.n, self.d)
def main():
n,m = LI()
a = LI()
w = LI()
fm = {}
def f(c,a,m,p,q):
if m == 0 or c == 0:
return MF(c, 1)
key = (c,a,m,p,q)
if key in fm:
return fm[key]
s = c + p + q
x = f(c+a,a,m-1,p,q)
r = x * MF(c, s)
if p > 0:
y = f(c,a,m-1,p+1,q)
r = r + y * MF(p, s)
if q > 0:
z = f(c,a,m-1,p,q-1)
r = r + z * MF(q, s)
fm[key] = r
return r
ps = 0
qs = 0
for i in range(n):
if a[i] == 1:
ps += w[i]
else:
qs += w[i]
r = []
for i in range(n):
if a[i] == 1:
v = f(w[i],1,m,ps-w[i],qs)
else:
v = f(w[i],-1,m,ps,qs-w[i])
r.append(v.int())
return JA(r,'\n')
print(main())
``` | output | 1 | 25,646 | 14 | 51,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Nauuo is a girl who loves random picture websites.
One day she made a random picture website by herself which includes n pictures.
When Nauuo visits the website, she sees exactly one picture. The website does not display each picture with equal probability. The i-th picture has a non-negative weight w_i, and the probability of the i-th picture being displayed is \frac{w_i}{∑_{j=1}^nw_j}. That is to say, the probability of a picture to be displayed is proportional to its weight.
However, Nauuo discovered that some pictures she does not like were displayed too often.
To solve this problem, she came up with a great idea: when she saw a picture she likes, she would add 1 to its weight; otherwise, she would subtract 1 from its weight.
Nauuo will visit the website m times. She wants to know the expected weight of each picture after all the m visits modulo 998244353. Can you help her?
The expected weight of the i-th picture can be denoted by \frac {q_i} {p_i} where \gcd(p_i,q_i)=1, you need to print an integer r_i satisfying 0≤ r_i<998244353 and r_i⋅ p_i≡ q_i\pmod{998244353}. It can be proved that such r_i exists and is unique.
Input
The first line contains two integers n and m (1≤ n≤ 50, 1≤ m≤ 50) — the number of pictures and the number of visits to the website.
The second line contains n integers a_1,a_2,…,a_n (a_i is either 0 or 1) — if a_i=0 , Nauuo does not like the i-th picture; otherwise Nauuo likes the i-th picture. It is guaranteed that there is at least one picture which Nauuo likes.
The third line contains n integers w_1,w_2,…,w_n (1≤ w_i≤50) — the initial weights of the pictures.
Output
The output contains n integers r_1,r_2,…,r_n — the expected weights modulo 998244353.
Examples
Input
2 1
0 1
2 1
Output
332748119
332748119
Input
1 2
1
1
Output
3
Input
3 3
0 1 1
4 3 5
Output
160955686
185138929
974061117
Note
In the first example, if the only visit shows the first picture with a probability of \frac 2 3, the final weights are (1,1); if the only visit shows the second picture with a probability of \frac1 3, the final weights are (2,2).
So, both expected weights are \frac2 3⋅ 1+\frac 1 3⋅ 2=\frac4 3 .
Because 332748119⋅ 3≡ 4\pmod{998244353}, you need to print 332748119 instead of \frac4 3 or 1.3333333333.
In the second example, there is only one picture which Nauuo likes, so every time Nauuo visits the website, w_1 will be increased by 1.
So, the expected weight is 1+2=3.
Nauuo is very naughty so she didn't give you any hint of the third example. | instruction | 0 | 25,647 | 14 | 51,294 |
Tags: dp, probabilities
Correct Solution:
```
P = 998244353
N, M = map(int, input().split())
A = [int(a) for a in input().split()]
B = [int(a) for a in input().split()]
li = sum([A[i]*B[i] for i in range(N)])
di = sum([(A[i]^1)*B[i] for i in range(N)])
X = [[] for _ in range(M+1)]
X[0] = [1]
def calc(L):
su = sum(L)
pl = 0
pd = 0
RE = []
for i in range(len(L)):
a = li + i
b = di - (len(L) - 1 - i)
pd = b * L[i] * pow(su*(a+b), P-2, P)
RE.append((pl+pd)%P)
pl = a * L[i] * pow(su*(a+b), P-2, P)
RE.append(pl%P)
return RE
for i in range(M):
X[i+1] = calc(X[i])
ne = 0
po = 0
for i in range(M+1):
po = (po + X[M][i] * (li + i)) % P
ne = (ne + X[M][i] * (di - M + i)) % P
for i in range(N):
print(po * B[i] * pow(li, P-2, P) % P if A[i] else ne * B[i] * pow(di, P-2, P) % P)
``` | output | 1 | 25,647 | 14 | 51,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Nauuo is a girl who loves random picture websites.
One day she made a random picture website by herself which includes n pictures.
When Nauuo visits the website, she sees exactly one picture. The website does not display each picture with equal probability. The i-th picture has a non-negative weight w_i, and the probability of the i-th picture being displayed is \frac{w_i}{∑_{j=1}^nw_j}. That is to say, the probability of a picture to be displayed is proportional to its weight.
However, Nauuo discovered that some pictures she does not like were displayed too often.
To solve this problem, she came up with a great idea: when she saw a picture she likes, she would add 1 to its weight; otherwise, she would subtract 1 from its weight.
Nauuo will visit the website m times. She wants to know the expected weight of each picture after all the m visits modulo 998244353. Can you help her?
The expected weight of the i-th picture can be denoted by \frac {q_i} {p_i} where \gcd(p_i,q_i)=1, you need to print an integer r_i satisfying 0≤ r_i<998244353 and r_i⋅ p_i≡ q_i\pmod{998244353}. It can be proved that such r_i exists and is unique.
Input
The first line contains two integers n and m (1≤ n≤ 50, 1≤ m≤ 50) — the number of pictures and the number of visits to the website.
The second line contains n integers a_1,a_2,…,a_n (a_i is either 0 or 1) — if a_i=0 , Nauuo does not like the i-th picture; otherwise Nauuo likes the i-th picture. It is guaranteed that there is at least one picture which Nauuo likes.
The third line contains n integers w_1,w_2,…,w_n (1≤ w_i≤50) — the initial weights of the pictures.
Output
The output contains n integers r_1,r_2,…,r_n — the expected weights modulo 998244353.
Examples
Input
2 1
0 1
2 1
Output
332748119
332748119
Input
1 2
1
1
Output
3
Input
3 3
0 1 1
4 3 5
Output
160955686
185138929
974061117
Note
In the first example, if the only visit shows the first picture with a probability of \frac 2 3, the final weights are (1,1); if the only visit shows the second picture with a probability of \frac1 3, the final weights are (2,2).
So, both expected weights are \frac2 3⋅ 1+\frac 1 3⋅ 2=\frac4 3 .
Because 332748119⋅ 3≡ 4\pmod{998244353}, you need to print 332748119 instead of \frac4 3 or 1.3333333333.
In the second example, there is only one picture which Nauuo likes, so every time Nauuo visits the website, w_1 will be increased by 1.
So, the expected weight is 1+2=3.
Nauuo is very naughty so she didn't give you any hint of the third example. | instruction | 0 | 25,648 | 14 | 51,296 |
Tags: dp, probabilities
Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def inv(x):
return pow(x, mod - 2, mod)
def main():
n,m = LI()
a = LI()
w = LI()
def plus(a,b):
c = a[0] * b[1] % mod
d = b[0] * a[1] % mod
e = a[1] * b[1] % mod
return [(c+d)%mod, e]
def sub(a,b):
c = a[0] * b[1] % mod
d = -b[0] * a[1] % mod
e = a[1] * b[1] % mod
return [(c+d)%mod, e]
def mul(a,b):
c = a[0] * b[0] % mod
d = a[1] * b[1] % mod
return [c,d]
fm = {}
def f(c,a,m,p,q):
if m == 0 or c == 0:
return [c, 1]
key = (c,a,m,p,q)
if key in fm:
return fm[key]
s = c + p + q
x = f(c+a,a,m-1,p,q)
r = mul(x, [c, s])
if p > 0:
y = f(c,a,m-1,p+1,q)
r = plus(r, mul(y, [p, s]))
if q > 0:
z = f(c,a,m-1,p,q-1)
r = plus(r, mul(z, [q, s]))
fm[key] = r
return r
ps = 0
qs = 0
for i in range(n):
if a[i] == 1:
ps += w[i]
else:
qs += w[i]
r = []
for i in range(n):
if a[i] == 1:
v = f(w[i],1,m,ps-w[i],qs)
else:
v = f(w[i],-1,m,ps,qs-w[i])
r.append(v[0]*inv(v[1]) % mod)
return JA(r,'\n')
print(main())
``` | output | 1 | 25,648 | 14 | 51,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Nauuo is a girl who loves random picture websites.
One day she made a random picture website by herself which includes n pictures.
When Nauuo visits the website, she sees exactly one picture. The website does not display each picture with equal probability. The i-th picture has a non-negative weight w_i, and the probability of the i-th picture being displayed is \frac{w_i}{∑_{j=1}^nw_j}. That is to say, the probability of a picture to be displayed is proportional to its weight.
However, Nauuo discovered that some pictures she does not like were displayed too often.
To solve this problem, she came up with a great idea: when she saw a picture she likes, she would add 1 to its weight; otherwise, she would subtract 1 from its weight.
Nauuo will visit the website m times. She wants to know the expected weight of each picture after all the m visits modulo 998244353. Can you help her?
The expected weight of the i-th picture can be denoted by \frac {q_i} {p_i} where \gcd(p_i,q_i)=1, you need to print an integer r_i satisfying 0≤ r_i<998244353 and r_i⋅ p_i≡ q_i\pmod{998244353}. It can be proved that such r_i exists and is unique.
Input
The first line contains two integers n and m (1≤ n≤ 50, 1≤ m≤ 50) — the number of pictures and the number of visits to the website.
The second line contains n integers a_1,a_2,…,a_n (a_i is either 0 or 1) — if a_i=0 , Nauuo does not like the i-th picture; otherwise Nauuo likes the i-th picture. It is guaranteed that there is at least one picture which Nauuo likes.
The third line contains n integers w_1,w_2,…,w_n (1≤ w_i≤50) — the initial weights of the pictures.
Output
The output contains n integers r_1,r_2,…,r_n — the expected weights modulo 998244353.
Examples
Input
2 1
0 1
2 1
Output
332748119
332748119
Input
1 2
1
1
Output
3
Input
3 3
0 1 1
4 3 5
Output
160955686
185138929
974061117
Note
In the first example, if the only visit shows the first picture with a probability of \frac 2 3, the final weights are (1,1); if the only visit shows the second picture with a probability of \frac1 3, the final weights are (2,2).
So, both expected weights are \frac2 3⋅ 1+\frac 1 3⋅ 2=\frac4 3 .
Because 332748119⋅ 3≡ 4\pmod{998244353}, you need to print 332748119 instead of \frac4 3 or 1.3333333333.
In the second example, there is only one picture which Nauuo likes, so every time Nauuo visits the website, w_1 will be increased by 1.
So, the expected weight is 1+2=3.
Nauuo is very naughty so she didn't give you any hint of the third example.
Submitted Solution:
```
import sys
def modinv(n, p):
q = p-2
ans = 1
mult = n
while q > 0:
if q % 2 == 1:
q = q - 1
ans = (ans * mult) % p
else:
q = q // 2
mult = (mult * mult) % p
return ans
n, m = list(map(int, sys.stdin.readline().strip().split()))
a = list(map(int, sys.stdin.readline().strip().split()))
w = list(map(int, sys.stdin.readline().strip().split()))
p = 998244353
L = 0
D = 0
W = 0
for i in range (0, n):
if a[i] == 0:
D = D + w[i]
else:
L = L + w[i]
W = W + w[i]
L0 = L
D0 = D
for i in range (0, m):
W1 = modinv(W, p)
D, L = (D - D * W1) % p, (L + L * W1) % p
# D, L = (D - D / W), (L + L / W)
W = (D + L) % p
for i in range (0, n):
if a[i] == 0:
w[i] = w[i] * D * modinv(D0, p) % p
else:
w[i] = w[i] * L * modinv(L0, p) % p
for i in range (0, n):
print(w[i])
``` | instruction | 0 | 25,649 | 14 | 51,298 |
No | output | 1 | 25,649 | 14 | 51,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Nauuo is a girl who loves random picture websites.
One day she made a random picture website by herself which includes n pictures.
When Nauuo visits the website, she sees exactly one picture. The website does not display each picture with equal probability. The i-th picture has a non-negative weight w_i, and the probability of the i-th picture being displayed is \frac{w_i}{∑_{j=1}^nw_j}. That is to say, the probability of a picture to be displayed is proportional to its weight.
However, Nauuo discovered that some pictures she does not like were displayed too often.
To solve this problem, she came up with a great idea: when she saw a picture she likes, she would add 1 to its weight; otherwise, she would subtract 1 from its weight.
Nauuo will visit the website m times. She wants to know the expected weight of each picture after all the m visits modulo 998244353. Can you help her?
The expected weight of the i-th picture can be denoted by \frac {q_i} {p_i} where \gcd(p_i,q_i)=1, you need to print an integer r_i satisfying 0≤ r_i<998244353 and r_i⋅ p_i≡ q_i\pmod{998244353}. It can be proved that such r_i exists and is unique.
Input
The first line contains two integers n and m (1≤ n≤ 50, 1≤ m≤ 50) — the number of pictures and the number of visits to the website.
The second line contains n integers a_1,a_2,…,a_n (a_i is either 0 or 1) — if a_i=0 , Nauuo does not like the i-th picture; otherwise Nauuo likes the i-th picture. It is guaranteed that there is at least one picture which Nauuo likes.
The third line contains n integers w_1,w_2,…,w_n (1≤ w_i≤50) — the initial weights of the pictures.
Output
The output contains n integers r_1,r_2,…,r_n — the expected weights modulo 998244353.
Examples
Input
2 1
0 1
2 1
Output
332748119
332748119
Input
1 2
1
1
Output
3
Input
3 3
0 1 1
4 3 5
Output
160955686
185138929
974061117
Note
In the first example, if the only visit shows the first picture with a probability of \frac 2 3, the final weights are (1,1); if the only visit shows the second picture with a probability of \frac1 3, the final weights are (2,2).
So, both expected weights are \frac2 3⋅ 1+\frac 1 3⋅ 2=\frac4 3 .
Because 332748119⋅ 3≡ 4\pmod{998244353}, you need to print 332748119 instead of \frac4 3 or 1.3333333333.
In the second example, there is only one picture which Nauuo likes, so every time Nauuo visits the website, w_1 will be increased by 1.
So, the expected weight is 1+2=3.
Nauuo is very naughty so she didn't give you any hint of the third example.
Submitted Solution:
```
def modInverse(a, m) :
g = gcd(a, m)
if (g != 1) :
pass
else :
return power(a, m - 2, m)
# To compute x^y under modulo m
def power(x, y, m) :
if (y == 0) :
return 1
p = power(x, y // 2, m) % m
p = (p * p) % m
if(y % 2 == 0) :
return p
else :
return ((x * p) % m)
# Function to return gcd of a and b
def gcd(a, b) :
if (a == 0) :
return b
return gcd(b % a, a)
import sys
from fractions import Fraction
input = sys.stdin.readline
n, m = [ int(x) for x in input().strip().split() ]
a = [ 1 if int(x)==1 else -1 for x in input().strip().split() ]
w = [ int(x) for x in input().strip().split() ]
s = sum(w)
p = 998244353
res = []
for i in range(n):
w_i = Fraction(w[i]*(s+m*a[i])/s).limit_denominator()
res.append((w_i.numerator, w_i.denominator))
for r in res:
ans = r[0]
ans*=modInverse(r[1],p)
print(ans%p)
``` | instruction | 0 | 25,650 | 14 | 51,300 |
No | output | 1 | 25,650 | 14 | 51,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Nauuo is a girl who loves random picture websites.
One day she made a random picture website by herself which includes n pictures.
When Nauuo visits the website, she sees exactly one picture. The website does not display each picture with equal probability. The i-th picture has a non-negative weight w_i, and the probability of the i-th picture being displayed is \frac{w_i}{∑_{j=1}^nw_j}. That is to say, the probability of a picture to be displayed is proportional to its weight.
However, Nauuo discovered that some pictures she does not like were displayed too often.
To solve this problem, she came up with a great idea: when she saw a picture she likes, she would add 1 to its weight; otherwise, she would subtract 1 from its weight.
Nauuo will visit the website m times. She wants to know the expected weight of each picture after all the m visits modulo 998244353. Can you help her?
The expected weight of the i-th picture can be denoted by \frac {q_i} {p_i} where \gcd(p_i,q_i)=1, you need to print an integer r_i satisfying 0≤ r_i<998244353 and r_i⋅ p_i≡ q_i\pmod{998244353}. It can be proved that such r_i exists and is unique.
Input
The first line contains two integers n and m (1≤ n≤ 50, 1≤ m≤ 50) — the number of pictures and the number of visits to the website.
The second line contains n integers a_1,a_2,…,a_n (a_i is either 0 or 1) — if a_i=0 , Nauuo does not like the i-th picture; otherwise Nauuo likes the i-th picture. It is guaranteed that there is at least one picture which Nauuo likes.
The third line contains n integers w_1,w_2,…,w_n (1≤ w_i≤50) — the initial weights of the pictures.
Output
The output contains n integers r_1,r_2,…,r_n — the expected weights modulo 998244353.
Examples
Input
2 1
0 1
2 1
Output
332748119
332748119
Input
1 2
1
1
Output
3
Input
3 3
0 1 1
4 3 5
Output
160955686
185138929
974061117
Note
In the first example, if the only visit shows the first picture with a probability of \frac 2 3, the final weights are (1,1); if the only visit shows the second picture with a probability of \frac1 3, the final weights are (2,2).
So, both expected weights are \frac2 3⋅ 1+\frac 1 3⋅ 2=\frac4 3 .
Because 332748119⋅ 3≡ 4\pmod{998244353}, you need to print 332748119 instead of \frac4 3 or 1.3333333333.
In the second example, there is only one picture which Nauuo likes, so every time Nauuo visits the website, w_1 will be increased by 1.
So, the expected weight is 1+2=3.
Nauuo is very naughty so she didn't give you any hint of the third example.
Submitted Solution:
```
P = 998244353
N, M = map(int, input().split())
A = [int(a) for a in input().split()]
B = [int(a) for a in input().split()]
li = sum([A[i]*B[i] for i in range(N)])
di = sum([(A[i]^1)*B[i] for i in range(N)])
X = [[] for _ in range(M+1)]
X[0] = [1]
def calc(L):
su = sum(L)
pl = 0
pd = 0
RE = []
for i in range(len(L)):
a = li + i
b = di - (len(L) - 1 - i)
pd = b * L[i] * pow(su*(a+b), P-2, P)
RE.append((pl+pd)%P)
pl = a * L[i] * pow(su*(a+b), P-2, P)
RE.append(pl%P)
return RE
for i in range(M):
X[i+1] = calc(X[i])
ne = 0
po = 0
for i in range(M+1):
po = (po + X[M][i] * (li + i)) % P
ne = (ne + X[M][i] * (di + i)) % P
for i in range(N):
print(po * B[i] * pow(li, P-2, P) % P if A[i] else ne * B[i] * pow(di, P-2, P) % P)
``` | instruction | 0 | 25,651 | 14 | 51,302 |
No | output | 1 | 25,651 | 14 | 51,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Nauuo is a girl who loves random picture websites.
One day she made a random picture website by herself which includes n pictures.
When Nauuo visits the website, she sees exactly one picture. The website does not display each picture with equal probability. The i-th picture has a non-negative weight w_i, and the probability of the i-th picture being displayed is \frac{w_i}{∑_{j=1}^nw_j}. That is to say, the probability of a picture to be displayed is proportional to its weight.
However, Nauuo discovered that some pictures she does not like were displayed too often.
To solve this problem, she came up with a great idea: when she saw a picture she likes, she would add 1 to its weight; otherwise, she would subtract 1 from its weight.
Nauuo will visit the website m times. She wants to know the expected weight of each picture after all the m visits modulo 998244353. Can you help her?
The expected weight of the i-th picture can be denoted by \frac {q_i} {p_i} where \gcd(p_i,q_i)=1, you need to print an integer r_i satisfying 0≤ r_i<998244353 and r_i⋅ p_i≡ q_i\pmod{998244353}. It can be proved that such r_i exists and is unique.
Input
The first line contains two integers n and m (1≤ n≤ 50, 1≤ m≤ 50) — the number of pictures and the number of visits to the website.
The second line contains n integers a_1,a_2,…,a_n (a_i is either 0 or 1) — if a_i=0 , Nauuo does not like the i-th picture; otherwise Nauuo likes the i-th picture. It is guaranteed that there is at least one picture which Nauuo likes.
The third line contains n integers w_1,w_2,…,w_n (1≤ w_i≤50) — the initial weights of the pictures.
Output
The output contains n integers r_1,r_2,…,r_n — the expected weights modulo 998244353.
Examples
Input
2 1
0 1
2 1
Output
332748119
332748119
Input
1 2
1
1
Output
3
Input
3 3
0 1 1
4 3 5
Output
160955686
185138929
974061117
Note
In the first example, if the only visit shows the first picture with a probability of \frac 2 3, the final weights are (1,1); if the only visit shows the second picture with a probability of \frac1 3, the final weights are (2,2).
So, both expected weights are \frac2 3⋅ 1+\frac 1 3⋅ 2=\frac4 3 .
Because 332748119⋅ 3≡ 4\pmod{998244353}, you need to print 332748119 instead of \frac4 3 or 1.3333333333.
In the second example, there is only one picture which Nauuo likes, so every time Nauuo visits the website, w_1 will be increased by 1.
So, the expected weight is 1+2=3.
Nauuo is very naughty so she didn't give you any hint of the third example.
Submitted Solution:
```
from fractions import Fraction as F
n, m = [int(i) for i in input().split()]
pm = [i == '1' for i in input().split()]
weights = [F(int(i)) for i in input().split()]
#print(pm)
for v in range(m):
k = sum(weights)
plus = 1 + 1 / k
minus = 1 - 1 / k
#print("pm:", plus, minus)
#print(weights)
for i in range(n):
if pm[i]:
#print(weights[i], weights[i] * plus)
weights[i] *= plus
else:
weights[i] *= minus
#print(weights)
#import math
mod = 998244353
for w in weights:
#print(w)
print((w.numerator * pow(w.denominator, mod - 2, mod))%mod)
``` | instruction | 0 | 25,652 | 14 | 51,304 |
No | output | 1 | 25,652 | 14 | 51,305 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121 | instruction | 0 | 25,653 | 14 | 51,306 |
Tags: dp
Correct Solution:
```
n1,n2,k1,k2 = map(int,input().split())
dp = []
for i in range(n1+1):
t = []
for j in range(n2+1):
u = []
for g in range(k1+1):
v = []
for h in range(k2+1):
v.append(-1)
u.append(v)
t.append(u)
dp.append(t)
def solve(t1,t2,c1,c2):
if c1>k1 or c2>k2 or t1>n1 or t2>n2:
return 0
if t1==n1 and t2 == n2:
return 1
if dp[t1][t2][c1][c2] != -1:
return dp[t1][t2][c1][c2]
else:
a = solve(t1+1,t2,c1+1,0)
b = solve(t1,t2+1,0,c2+1)
dp[t1][t2][c1][c2] =(a+b)%(10**8)
return dp[t1][t2][c1][c2]
print(solve(0,0,0,0))
``` | output | 1 | 25,653 | 14 | 51,307 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121 | instruction | 0 | 25,654 | 14 | 51,308 |
Tags: dp
Correct Solution:
```
def dp(footman, horseman, i, j):
if(state[footman][horseman][i][j]!=-1):
return state[footman][horseman][i][j]
if(footman+horseman==0):
return 1
ret1, ret2 = 0, 0
if(i<k1 and footman>0):
ret1 = dp(footman-1, horseman, i+1, 0)
if(j<k2 and horseman>0):
ret2 = dp(footman, horseman-1, 0, j+1)
state[footman][horseman][i][j] = int((ret1+ret2)%1e8)
return state[footman][horseman][i][j]
if __name__=="__main__":
n1, n2, k1, k2 = map(int, input().split())
state = [[[[-1 for _ in range(k2+1)] for _ in range(k1+1)] for _ in range(n2+1)] for _ in range(n1+1)]
print(dp(n1, n2, 0, 0))
``` | output | 1 | 25,654 | 14 | 51,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121 | instruction | 0 | 25,655 | 14 | 51,310 |
Tags: dp
Correct Solution:
```
n_1, n_2, k_1, k_2 = map(int, input().split())
dp = [[[0] * 2 for _ in range(n_2+1)] for _ in range(n_1+1)]
dp[0][0][0] = dp[0][0][1] = 1
for i in range(n_1+1):
for j in range(n_2+1):
for k in range(1, min(k_1, i)+1):
dp[i][j][0] += dp[i-k][j][1]
dp[i][j][0] %= 10**8
for k in range(1, min(k_2, j)+1):
dp[i][j][1] += dp[i][j-k][0]
dp[i][j][1] %= 10**8
print(sum(dp[n_1][n_2])%10**8)
``` | output | 1 | 25,655 | 14 | 51,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121 | instruction | 0 | 25,656 | 14 | 51,312 |
Tags: dp
Correct Solution:
```
global K1
global K2
global dp
def numArr(n1,n2,k1,k2):
if (n1+n2) == 0: return 1
if (dp[n1][n2][k1][k2]!=-1): return dp[n1][n2][k1][k2]
val1 = 0
val2 = 0
if n1 > 0 and k1 > 0: val1 = numArr(n1-1,n2,k1-1,K2)
if n2 > 0 and k2 > 0: val2 = numArr(n1,n2-1,K1,k2-1)
dp[n1][n2][k1][k2] = (val1 + val2)%100000000
return dp[n1][n2][k1][k2]
n1,n2,k1,k2 = map(int,input().split())
K1 = min(k1,n1)
K2 = min(k2,n2)
dp = [[[[-1 for i in range(K2+1)] for j in range(K1+1)] for x in range(n2+1)] for y in range(n1+1)]
print(numArr(n1,n2,K1,K2))
``` | output | 1 | 25,656 | 14 | 51,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121 | instruction | 0 | 25,657 | 14 | 51,314 |
Tags: dp
Correct Solution:
```
def cal(a, b, i, j):
if min(a, b, i, j) < 0:
return 0
if a == 0 and b == 0:
return 1
v = (a, b, i, j)
if not v in M:
M[v] = (cal(a-1, b, i-1, y) + cal(a, b-1, x, j-1))%10**8
return M[v]
n, m, x, y = map(int, input().split())
M = {}
print(cal(n, m, x, y))
``` | output | 1 | 25,657 | 14 | 51,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121 | instruction | 0 | 25,658 | 14 | 51,316 |
Tags: dp
Correct Solution:
```
import functools
p=100000000
@functools.lru_cache(maxsize= None)
def f(n1,n2,k1,k2):
global c
global d
if(n1==0):
return int(n2<=k2)
if(n2==0):
#print('hi')
return int(n1<=k1)
if(k1==0):
return f(n1,n2-1,c,k2-1)%p
if(k2==0):
return f(n1-1,n2,k1-1,d)%p
return (f(n1-1,n2,k1-1,d)+f(n1,n2-1,c,k2-1))%p
a,b,c,d=map(int,input().split())
#print(n1,n2,k1,k2)
print((f(a,b,c,d))%p)
``` | output | 1 | 25,658 | 14 | 51,317 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121 | instruction | 0 | 25,659 | 14 | 51,318 |
Tags: dp
Correct Solution:
```
n1_, n2_, k1_, k2_ = map(int, input().split())
dp = {}
def d(n1, n2, k1, k2):
if min(n1, n2, k1, k2) < 0:
return 0
if n1 == 0 and n2 == 0:
return 1
par = (n1, n2, k1, k2)
if par in dp:
return dp[par]
else:
dp[par] = d(n1 - 1, n2, k1 - 1, k2_) + d(n1, n2 - 1, k1_, k2 - 1)
dp[par] = dp[par] % (10 ** 8)
return dp[par]
ans = d(n1_, n2_, k1_, k2_)
print(ans)
``` | output | 1 | 25,659 | 14 | 51,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121 | instruction | 0 | 25,660 | 14 | 51,320 |
Tags: dp
Correct Solution:
```
n1,n2,k1,k2=map(int,input().split())
mod=10**8
dp=[[[[0]*2 for i in range(n1+1)] for j in range(max(k1,k2)+1)] for k in range(n1+n2+1)]
dp[1][1][n1][1]=1
dp[1][1][n1-1][0]=1
for i in range(2,n1+n2+1):
# l=0
for j in range(2,k1+1):
for k in range(n1):
dp[i][j][k][0]+=dp[i-1][j-1][k+1][0]
dp[i][j][k][0]%=mod
for j in range(1,k1+1):
for k in range(n1+1):
dp[i][1][k][1]+=dp[i-1][j][k][0]
dp[i][1][k][1]%=mod
# l=1
for j in range(2,k2+1):
for k in range(n1+1):
dp[i][j][k][1]+=dp[i-1][j-1][k][1]
dp[i][j][k][1]%=mod
for j in range(1,k2+1):
for k in range(n1):
dp[i][1][k][0]+=dp[i-1][j][k+1][1]
dp[i][1][k][0]%=mod
ans=0
for j in range(max(k1,k2)+1):
ans+=sum(dp[n1+n2][j][0])
ans%=mod
print(ans)
``` | output | 1 | 25,660 | 14 | 51,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121
Submitted Solution:
```
from sys import stdin, stdout, setrecursionlimit
input = stdin.readline
# setrecursionlimit(int(1e6))
inf = float('inf')
from collections import defaultdict as dd
from collections import Counter, deque
from heapq import *
import math
from math import floor, ceil, sqrt
def geti(): return map(int, input().strip().split())
def getl(): return list(map(int, input().strip().split()))
def getis(): return map(str, input().strip().split())
def getls(): return list(map(str, input().strip().split()))
def gets(): return input().strip()
def geta(): return int(input())
def print_s(s): stdout.write(s+'\n')
def solve():
mod = int(1e8)
n1, n2, k1, k2 = geti()
ans = dd(int)
def dp(a1, a2, b1, b2):
temp = (a1, a2, b1, b2)
if temp in ans:
return ans[temp]
if b1 > k1 or b2 > k2 or a1 > n1 or a2 > n2:
return 0
if (a1 + a2) == (n1 + n2):
return 1
# print(a1, a2, b1, b2)
a = dp(a1+1, a2, b1+1, 0)
b = dp(a1, a2+1, 0, b2+1)
ans[temp] = (a + b) % mod
return (a + b) % mod
now = dp(1,0,1,0) + dp(0,1,0,1)
print(now % mod)
# print(ans)
if __name__=='__main__':
solve()
``` | instruction | 0 | 25,661 | 14 | 51,322 |
Yes | output | 1 | 25,661 | 14 | 51,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121
Submitted Solution:
```
# code
''' LIS
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
a1 = [1 for _ in range(n)]
i, j = 1, 0
while (i < n ):
#print(i,j,a[i],a[j])
if a[i] > a[j]:
#print(a1[i],a1[j])
a1[i] =max(1+ a1[j],a1[i])
j += 1
else:
j += 1
if i == j:
j = 0
i += 1
print(a1)
#LCSubstring
t=int(input())
for _ in range(t):
a,b=map(int,input().split())
s1=input()
s2=input()
n=[[0 for _ in range(b+1)]for _ in range(a+1)]
r=0
for i in range(1,a+1):
for j in range(1,b+1):
print(i,j)
if i==0 or j==0:
n[i][j]=0
continue
elif s1[i-1]==s2[j-1]:
print("here",n[i-1][j-1])
n[i][j]=1+n[i-1][j-1]
r=max(r,1+n[i-1][j-1])
print(n)
print(r)
#LCSubsequnce
t=int(input())
for _ in range(t):
a,b=map(int,input().split())
s1=input()
s2=input()
n=[[0 for _ in range(b+1)]for _ in range(a+1)]
r=0
for i in range(1,a+1):
for j in range(1,b+1):
if i==0 or j==0:
n[i][j]=0
continue
elif s1[i-1]==s2[j-1]:
n[i][j]=1+n[i-1][j-1]
else:
n[i][j]=max(n[i-1][j],n[i][j-1])
print(n[a][b])
#Hopping stones
def score(m,trip_jump,step):
if m==n-1:
return step*a[m-1]
if m==n-2:
return step*a[m]+a[m+1]
if m==n-3:
return max(a[m]+a[m+1],2*a[m+1])
else:
if trip_jump==1:
return step*a[m]+max(score(m+1,1,1),score(m+2,1,2))
else:
return step*a[m]+max(score(m+3,1,3),score(m+2,0,2),score(m+1,0,1))
n=int(input())
a=list(map(int,input().split()))
print(score(0,0,1),score(1,0,2),score(2,1,3))
#Uncertain steps
def count(n,trip_step):
if n==0:
return 1
if n==1:
return 1
if n==2:
return 2
if n==3:
if trip_step==0:
return 4
else:
return 3
if trip_step==0:
return count(n-1,0)+count(n-2,0)+count(n-3,1)
else:
return count(n-1,0)+count(n-2,0)
n=int(input())
print(count(n,0))
#GRID atcoder
import sys
sys.setrecursionlimit(20000)
def paths(i, j):
if i == h - 1 and j == w - 1:
return 1
if a[i][0][j] == '#':
return 0
if i < h - 1 and j < w - 1:
if dp[i][j] == -1:
dp[i][j] = paths(i + 1, j) + paths(i, j + 1)
return dp[i][j]
else:
return dp[i][j]
elif i == h - 1 and j < w - 1:
if dp[i][j] == -1:
dp[i][j] = paths(i, j + 1)
return dp[i][j]
else:
return dp[i][j]
elif i < h - 1 and j == w - 1:
if dp[i][j] == -1:
dp[i][j] = paths(i + 1, j)
return dp[i][j]
else:
return dp[i][j]
h, w = map(int, input().split())
a = [[] for _ in range(h)]
m = 1000000007
for i in range(h):
a[i].append(input())
dp = [[-1 for _ in range(1000)] for _ in range(1000)]
print(paths(0, 0) % m)
#Coins atCoder
import sys
sys.setrecursionlimit(20000)
def getCombi(h, t, n, s):
global subsum
global tp
print("called for", h, t, n, s, subsum)
if len(s) == n:
tp+=subsum
combs.append(s)
print('compl',subsum,tp)
subsum=1
return
if h > 0:
subsum *= p[len(s) ]
print('in h',subsum,s)
getCombi(h - 1, t, n, s + 'h')
if t > 0:
subsum *= (1 - p[len(s)])
print('in t',subsum,s)
getCombi(h, t - 1, n, s + 't')
n = int(input())
p = list(map(float, input().split()))
dp=[[0 for _ in range(n+1)]for _ in range(n+1)]
dp[0][0]=1 #j no. of heads in i coins
for i in range(1,n+1):
for j in range(i+1):
if j==0:
dp[i][j]=dp[i-1][j]*(1-p[i-1])
else:
dp[i][j] = dp[i - 1][j] * (1 - p[i-1]) + dp[i-1][j-1]*p[i-1]
print(dp)
#maximize sum Maximize the sum of selected numbers from an array to make it empty
def getMax(a,n,sel,ind,ans):
print("im function",a,n,sel,ind,ans)
if len(a)==1:
ans=max(ans,ans+a[0])
print(ans,"abs")
bs.append(ans)
return
selected=sel
selp1=sel+1
selm1=sel-1
f=0
l2=[]
f1=-1
f2=-1
f0=-1
print("updating list")
for k in range(n):
if a[k]!=selected and a[k]!=selm1 and a[k]!=selp1:
l2.append(a[k])
elif a[k]==selected:
if f0==-1:
ans+=a[k]
f0=0
continue
else:
l2.append(a[k])
else:
if a[k]==selp1:
if f1==-1:
f+=1
f1=0
continue
else:
l2.append(a[k])
if a[k]==selm1:
if f2==-1:
f+=1
f2=0
continue
else:
l2.append(a[k])
print("updated",l2,ans)
if len(l2)==0:
bs.append(ans)
ans = 0
return
for t in range(len(l2)):
getMax(l2,n-1-f,l2[t],t,ans)
a=list(map(int,input().split()))
n=len(a)
ans=0
bs=[]
for i in range(n):
getMax(a,n,a[i],i,ans)
print(max(bs))
'''
#maximum sum optimised
'''
#01 knapsack
def knap(n,cap):
if n==0 or cap==0:
return 0
if weight[n-1]>cap:
return knap(n-1,cap)
else:
return max(knap(n-1,cap),values[n-1]+knap(n-1,cap-weight[n-1]))
n=int(input())
cap = int(input())
values = list(map(int,input().split()))
weight = list(map(int,input().split()))
print(knap(n,cap))
dp=[[0 for _ in range(n+1)]for _ in range(cap+1)]
for i in range(cap+1):
for j in range(n+1):
if i==0 or j==0:
dp[i][j]=0
elif weight[j-1]>i:
dp[i][j]= dp[i-1][j]
else:
dp[i][j]=max(dp[i-1][j],weight[j-1]+dp[i-1][j-weight[j-1]])
print(dp[n][cap])
def count(r,c,k):
if c==n-1 and k>0:
return 0
if c>n-1:
return 0
if k==0:
return 1
if dp[k][r][c]==-1:
a=0
if r==0:
a+=count(1,c+1,k-1)
else:
a+=count(0,c+1,k-1)
for l in range(c+2,n):
a+=count(1,l,k-1)
a+=count(0,l,k-1)
dp[k][r][c]=a
return dp[k][r][c]
t=int(input())
for _ in range(t):
dp = [[[-1 for _ in range(1001)] for _ in range(2)]for _ in range(1001)]
n,k=map(int,input().split())
ans=0
if k>n:
print(ans)
continue
for i in range(n):
ans+=count(0,i,k-1)+count(1,i,k-1)
print(ans%1000000007)
######
DP Matrix chain multiplication
def brcc(i, j, n):
global nn
if i== j:
print(nn, end='')
nn = chr(ord(nn) + 1)
return
print('(', end='')
brcc(i, brc[i][j], n)
brcc(brc[i][j] + 1, j, n)
print(')', end='')
def getmin(i, j):
if j <= i+1:
return 0
if dp[i][j] == -1:
c = float('inf')
for k in range(i + 1, j):
c1 = getmin(i, k) + getmin(k, j) + a[i] * a[k] * a[j]
if c1 < c:
c = c1
dp[i][j]=c
brc[i+1][j] = k
return dp[i][j]
print(list(zip([i + 1 for i in range(5)], [] * 5)))
g = dict.fromkeys(list(zip([i + 1 for i in range(5)], [] * 5)))
print(g)
t = int(input())
for _ in range(t):
n = int(input())
nn='A'
a = list(map(int, input().split()))
dp = [[-1 for _ in range(n )] for _ in range(n )]
for k in range(n):
dp[k][k]=0
brc = [[0 for _ in range(n)] for _ in range(n)]
getmin(0, n - 1)
print(dp[0][n-1])
brcc(1, n-1, n)
'''
def count(k1,k2,kf,kh):
global k11
global k22
if kf>k11 or kh>k22:
return 0
if k1==0 and k2==0:
return 1
if dp[k1][k2][kf][kh] == -1:
if k2>0 and k1==0:
dp[k1][k2][kf][kh] =count(k1,k2-1,0,kh+1)
if k1>0 and k2==0:
dp[k1][k2][kf][kh] =count(k1-1,k2,kf+1,0)
if k1>0 and k2>0:
dp[k1][k2][kf][kh] =count(k1-1,k2,kf+1,0)+count(k1,k2-1,0,kh+1)
return dp[k1][k2][kf][kh]
n1,n2,k11,k22=map(int,input().split())
dp=[[[[-1 for _ in range(k22+1)]for _ in range(k11+1)]for _ in range(n2+1)]for _ in range(n1+1) ]
ans=count(n1,n2,0,0)
print(ans%100000000)
``` | instruction | 0 | 25,662 | 14 | 51,324 |
Yes | output | 1 | 25,662 | 14 | 51,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gaius Julius Caesar, a famous general, loved to line up his soldiers. Overall the army had n1 footmen and n2 horsemen. Caesar thought that an arrangement is not beautiful if somewhere in the line there are strictly more that k1 footmen standing successively one after another, or there are strictly more than k2 horsemen standing successively one after another. Find the number of beautiful arrangements of the soldiers.
Note that all n1 + n2 warriors should be present at each arrangement. All footmen are considered indistinguishable among themselves. Similarly, all horsemen are considered indistinguishable among themselves.
Input
The only line contains four space-separated integers n1, n2, k1, k2 (1 ≤ n1, n2 ≤ 100, 1 ≤ k1, k2 ≤ 10) which represent how many footmen and horsemen there are and the largest acceptable number of footmen and horsemen standing in succession, correspondingly.
Output
Print the number of beautiful arrangements of the army modulo 100000000 (108). That is, print the number of such ways to line up the soldiers, that no more than k1 footmen stand successively, and no more than k2 horsemen stand successively.
Examples
Input
2 1 1 10
Output
1
Input
2 3 1 2
Output
5
Input
2 4 1 1
Output
0
Note
Let's mark a footman as 1, and a horseman as 2.
In the first sample the only beautiful line-up is: 121
In the second sample 5 beautiful line-ups exist: 12122, 12212, 21212, 21221, 22121
Submitted Solution:
```
# Author : nitish420 --------------------------------------------------------------------
mod=10**8
from functools import lru_cache
@lru_cache(1000000)
def solve(p,q,r,s):
if r>a or s>b:
return 0
if p==x and q==y:
return 1
if p==x:
if y-q+s<=b:
return 1
else:
return 0
if q==y:
if x-p+r<=a:
return 1
else:
return 0
ans=0
ans=(ans+solve(p+1,q,r+1,0))%mod
ans=(ans+solve(p,q+1,0,s+1))%mod
return ans
x,y,a,b=map(int,input().split())
# check=set()
ans=(solve(1,0,1,0)%mod+solve(0,1,0,1)%mod)%mod
print(ans)
``` | instruction | 0 | 25,663 | 14 | 51,326 |
Yes | output | 1 | 25,663 | 14 | 51,327 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.