message stringlengths 2 28.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 21 109k | cluster float64 7 7 | __index_level_0__ int64 42 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We're giving away nice huge bags containing number tiles! A bag we want to present to you contains n tiles. Each of them has a single number written on it — either 1 or 2.
However, there is one condition you must fulfill in order to receive the prize. You will need to put all the tiles from the bag in a sequence, in any order you wish. We will then compute the sums of all prefixes in the sequence, and then count how many of these sums are prime numbers. If you want to keep the prize, you will need to maximize the number of primes you get.
Can you win the prize? Hurry up, the bags are waiting!
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of number tiles in the bag. The following line contains n space-separated integers a_1, a_2, ..., a_n (a_i ∈ \{1, 2\}) — the values written on the tiles.
Output
Output a permutation b_1, b_2, ..., b_n of the input sequence (a_1, a_2, ..., a_n) maximizing the number of the prefix sums being prime numbers. If there are multiple optimal permutations, output any.
Examples
Input
5
1 2 1 2 1
Output
1 1 1 2 2
Input
9
1 1 2 1 1 1 2 1 1
Output
1 1 1 2 1 1 1 2 1
Note
The first solution produces the prefix sums 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, \mathbf{\color{blue}{7}} (four primes constructed), while the prefix sums in the second solution are 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, 6, \mathbf{\color{blue}{7}}, 8, 10, \mathbf{\color{blue}{11}} (five primes). Primes are marked bold and blue. In each of these cases, the number of produced primes is maximum possible.
Submitted Solution:
```
n = int(input())
a=[]
a = input().split()
n1 = a.count("1")
n2 = a.count("2")
res = ""
if n1 == 1 and n2 >= 1:
res = res+"2 1 "
n2 = n2-1
for j in range(n2):
res = res+"2 "
if n1 == 2 and n2 >= 1:
res = res+"2 1 1 "
n2 = n2-1
for j in range(n2):
res = res+"2 "
else:
for i in range(n):
for j in range(3):
if n1 > 0 :
res = res+"1 "
n1=n1-1
if n2 > 0 :
n2 = n2-1
res = res+"2 "
print(res)
``` | instruction | 0 | 89,347 | 7 | 178,694 |
No | output | 1 | 89,347 | 7 | 178,695 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We're giving away nice huge bags containing number tiles! A bag we want to present to you contains n tiles. Each of them has a single number written on it — either 1 or 2.
However, there is one condition you must fulfill in order to receive the prize. You will need to put all the tiles from the bag in a sequence, in any order you wish. We will then compute the sums of all prefixes in the sequence, and then count how many of these sums are prime numbers. If you want to keep the prize, you will need to maximize the number of primes you get.
Can you win the prize? Hurry up, the bags are waiting!
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of number tiles in the bag. The following line contains n space-separated integers a_1, a_2, ..., a_n (a_i ∈ \{1, 2\}) — the values written on the tiles.
Output
Output a permutation b_1, b_2, ..., b_n of the input sequence (a_1, a_2, ..., a_n) maximizing the number of the prefix sums being prime numbers. If there are multiple optimal permutations, output any.
Examples
Input
5
1 2 1 2 1
Output
1 1 1 2 2
Input
9
1 1 2 1 1 1 2 1 1
Output
1 1 1 2 1 1 1 2 1
Note
The first solution produces the prefix sums 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, \mathbf{\color{blue}{7}} (four primes constructed), while the prefix sums in the second solution are 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, 6, \mathbf{\color{blue}{7}}, 8, 10, \mathbf{\color{blue}{11}} (five primes). Primes are marked bold and blue. In each of these cases, the number of produced primes is maximum possible.
Submitted Solution:
```
from math import sqrt
from collections import Counter
n = int(input())
arr = [int(i) for i in input().split()]
c = Counter(arr)
summa = sum(arr)
sieve = [True] * (summa + 1)
if summa == 1:
exit()
for i in range(2, int(sqrt(summa)) + 1):
if sieve[i]:
for j in range(i ** 2, summa + 1, i):
sieve[j] = False
s = 0
for i in range(2, summa + 1, 1):
ok = sieve[i]
if ok:
k = abs(i - s)
if k // 2:
if c[2] > k // 2:
s += (k // 2) * 2
c[2] -= k // 2
print((k // 2) * '2 ', end='')
k %= 2
elif c[2]:
print(c[2] * '2 ', end='')
k -= c[2] * 2
s += c[2] * 2
c[2] = 0
if k:
if c[1] > k:
print('1 ' * k, end='')
s += k
c[1] -= k
elif c[1]:
print(c[1] * '1 ', end='')
s += c[1]
c[1] = 0
``` | instruction | 0 | 89,348 | 7 | 178,696 |
No | output | 1 | 89,348 | 7 | 178,697 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
At Moscow Workshops ICPC team gets a balloon for each problem they solved first. Team MSU Red Panda got so many balloons that they didn't know how to spend them. So they came up with a problem with them.
There are several balloons, not more than 10^6 in total, each one is colored in one of k colors. We can perform the following operation: choose k-1 balloons such that they are of k-1 different colors, and recolor them all into remaining color. We can perform this operation any finite number of times (for example, we can only perform the operation if there are at least k-1 different colors among current balls).
How many different balloon configurations can we get? Only number of balloons of each color matters, configurations differing only by the order of balloons are counted as equal. As this number can be very large, output it modulo 998244353.
Input
The first line contains a single integer k (2 ≤ k ≤ 10^5) —the number of colors.
The second line contains k integers a_1, a_2, …, a_k (0 ≤ a_i) —initial configuration of balloons. a_i is number of balloons of color i. The total number of balloons doesn't exceed 10^6. In other words,
a_1 + a_2 + a_3 + … + a_k ≤ 10^6.
Output
Output number of possible configurations modulo 998244353.
Examples
Input
3
0 1 2
Output
3
Input
4
1 1 1 1
Output
5
Input
5
0 0 1 2 3
Output
1
Input
3
2 2 8
Output
31
Note
In the first example, there are 3 configurations we can get: [0, 1, 2], [2, 0, 1], [1, 2, 0].
In the second example, we can apply the operation not more than once, and possible configurations are: [1, 1, 1, 1], [0, 0, 0, 4], [0, 0, 4, 0], [0, 4, 0, 0], [4, 0, 0, 0].
In the third example, we can't apply any operations, so the only achievable configuration is the starting one.
Submitted Solution:
```
n = int(input())
print(pow(3, n - 1, 10 ** 9 + 7) - 1)
``` | instruction | 0 | 89,349 | 7 | 178,698 |
No | output | 1 | 89,349 | 7 | 178,699 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
| instruction | 0 | 90,515 | 7 | 181,030 |
Tags: combinatorics, dp, math
Correct Solution:
```
ans, col, mod = 1, 0, 1000000007
C = [[1 if i <= j else 0 for i in range(1001)] for j in range(1001)]
for i in range(1, 1001):
for j in range(1, i + 1):
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod
for _ in range(int(input())):
a = int(input())
ans *= C[col + a - 1][col]
ans %= mod
col += a
print(ans)
``` | output | 1 | 90,515 | 7 | 181,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
| instruction | 0 | 90,516 | 7 | 181,032 |
Tags: combinatorics, dp, math
Correct Solution:
```
mx=1001
mod=1000000007
nCr=[[0 for i in range(mx)] for j in range(mx)]
nCr[0][0]=1
for i in range(1,mx):
nCr[i][0]=1
for j in range(1,mx):
nCr[i][j]=nCr[i-1][j-1]+nCr[i-1][j]
n=int(input())
l=[]
for i in range(n):
l.append(int(input()))
res=1
total=0
for i in range(n):
res=(res*nCr[total+l[i]-1][l[i]-1])%mod
total+=l[i]
print(res)
``` | output | 1 | 90,516 | 7 | 181,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
| instruction | 0 | 90,517 | 7 | 181,034 |
Tags: combinatorics, dp, math
Correct Solution:
```
from math import factorial
k=int(input())
ans,s=1,0
for i in range(k):
ci=int(input())
ans=(ans*factorial(s+ci-1)//(factorial(ci-1)*factorial(s)))%1000000007
s+=ci
print(ans)
``` | output | 1 | 90,517 | 7 | 181,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
| instruction | 0 | 90,518 | 7 | 181,036 |
Tags: combinatorics, dp, math
Correct Solution:
```
from sys import stdin
n=int(stdin.readline())
from math import factorial as f
lst=[int(stdin.readline()) for _ in range(n)]
summa=sum(lst)
res=1
for i,x in enumerate(reversed(lst)):
x-=1
summa-=1
res*=(f(summa)//(f(summa-x)*f(x)))
res=res%1000000007
summa-=x
print(res)
``` | output | 1 | 90,518 | 7 | 181,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
| instruction | 0 | 90,519 | 7 | 181,038 |
Tags: combinatorics, dp, math
Correct Solution:
```
mod = 1000000007
def pow1(a,b):
ans = 1
c=a
while(b):
#print('estoy en el while')
if(b & 1):
ans=ans*c%mod
b>>=1
c=c*c%mod
return ans
def factorial(a,b):
factor =fact[a]*pow1(fact[b]*fact[a-b]%mod,mod-2)%mod
return factor
fact = []
for i in range(1000010):
fact.append(0)
a = []
for i in range(1010):
a.append(0)
#================MAIN===============
fact[0] = 1
for i in range(1,1000000):
fact[i]=fact[i-1]*i%mod
n = int(input())
#print(n)
sum = 0
for i in range(0,n):
a[i] = int(input())
sum+=a[i]
#print (a)
#print(sum)
ans = 1
i = n-1
while(i>-1):
ans=ans*factorial(sum-1,a[i]-1)%mod
#print(ans)
sum-=a[i]
i-=1
#print(f"suma:{sum}")
print(ans)
``` | output | 1 | 90,519 | 7 | 181,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
| instruction | 0 | 90,520 | 7 | 181,040 |
Tags: combinatorics, dp, math
Correct Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
mod=10**9+7
# sys.setrecursionlimit(10**6)
# mxm=sys.maxsize
# from functools import lru_cache
fact=[1]*(1002)
for i in range(2,1002):
fact[i]=(fact[i-1]*i)%mod
def ncr(n,r):
num=fact[n]
den=(fact[n-r]*fact[r])%mod
return (num*(pow(den,mod-2,mod)))%mod
def main():
k=int(input())
dp=[0]*(k+1)
dp[1]=1
dff=0
m=int(input())
total=m
for i in range(k-1):
m=int(input())
dff=m-1
total+=m
dp[i+2]=(dp[i+1]*ncr(total-1,dff))%mod
print(dp[k])
#----------------------------------------------------------------------------------------
def nouse0():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
def nouse1():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
def nouse2():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main()
``` | output | 1 | 90,520 | 7 | 181,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
| instruction | 0 | 90,521 | 7 | 181,042 |
Tags: combinatorics, dp, math
Correct Solution:
```
"""
Author - Satwik Tiwari .
4th Oct , 2020 - Sunday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil
from copy import deepcopy
from collections import deque
# from collections import Counter as counter # Counter(list) return a dict with {key: count}
# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
# from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
mod = 10**9+7
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
def nCr_mod(n,r,max_n=2 * 10**5, mod=10**9 + 7):
max_n = min(max_n, mod - 1)
fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)
fact[0] = 1
for i in range(max_n):
fact[i + 1] = fact[i] * (i + 1) % mod
inv_fact[-1] = pow(fact[-1], mod - 2, mod)
for i in reversed(range(max_n)):
inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod
def do_nCr_mod(n, r):
res = 1
while n or r:
a, b = n % mod, r % mod
if a < b:
return 0
res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod
n //= mod
r //= mod
return res
return do_nCr_mod(n,r)
"""
print nCr(4,3)
"""
def solve(case):
n = int(inp())
ans = 1
total = 0
for i in range(n):
x = int(inp())
total+= x
ans*=ncr(total-1,x-1)%mod
print(ans%mod)
testcase(1)
# testcase(int(inp()))
``` | output | 1 | 90,521 | 7 | 181,043 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
| instruction | 0 | 90,522 | 7 | 181,044 |
Tags: combinatorics, dp, math
Correct Solution:
```
# coding: utf-8
# In[6]:
matrix = [[0 for x in range(1001)] for y in range(1001)]
mod = 1000000007
def pascal():
matrix[0][0]=1;
for i in range(1001):
for j in range(1001):
if j==0 or j==i:
matrix[i][j]=1
else:
matrix[i][j] = (matrix[i-1][j-1]+matrix[i-1][j])%mod
a = int(input())
b = []
for i in range(a):
b.append(int(input()))
pascal()
r = 1
s = b[0]
for i in range(1,a):
r = (r*matrix[s + b[i]-1][b[i]-1])%mod
s += b[i]
print(r)
``` | output | 1 | 90,522 | 7 | 181,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
Submitted Solution:
```
pt = []
for i in range(1000):
pt.append([0] * (i + 1))
pt[i][0] = pt[i][i] = 1
for j in range(1, i):
pt[i][j] = pt[i - 1][j - 1] + pt[i - 1][j]
k, s, v = int(input()), int(input()), 1
for i in range(1, k):
c = int(input())
v = v * pt[s + c - 1][c - 1] % 1000000007
s += c
print(v)
``` | instruction | 0 | 90,523 | 7 | 181,046 |
Yes | output | 1 | 90,523 | 7 | 181,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
Submitted Solution:
```
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,factorial,gcd
from collections import deque
from bisect import bisect_right
k=int(input())
ans=1
total=0
MOD=1000000007
for i in range(k):
z=int(input())
ans=(ans*factorial(total+z-1)//factorial(total)//factorial(z-1))%MOD
total+=z
print(ans)
``` | instruction | 0 | 90,524 | 7 | 181,048 |
Yes | output | 1 | 90,524 | 7 | 181,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
Submitted Solution:
```
from math import *
from collections import deque
from copy import deepcopy
import sys
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def multi(): return map(int,input().split())
def strmulti(): return map(str, inp().split())
def lis(): return list(map(int, inp().split()))
def lcm(a,b): return (a*b)//gcd(a,b)
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def stringlis(): return list(map(str, inp().split()))
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def printlist(a) :
print(' '.join(str(a[i]) for i in range(len(a))))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#copied functions end
#start coding
k=int(input())
ans=1
sum=0
for i in range(k):
num=int(input())
sum+=num
ans*=(ncr(sum-1,num-1))
# print(ans)
print(ans%1000000007)
``` | instruction | 0 | 90,525 | 7 | 181,050 |
Yes | output | 1 | 90,525 | 7 | 181,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
Submitted Solution:
```
def binomialCoefficient(n, k):
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res // (i + 1)
return res
k=int(input())
sum=0
ans=1
m=1000000007
for i in range(k):
a=int(input())
ans=(ans%m)*(binomialCoefficient(sum+a-1,a-1))%m
sum+=a
print(ans)
``` | instruction | 0 | 90,526 | 7 | 181,052 |
Yes | output | 1 | 90,526 | 7 | 181,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
Submitted Solution:
```
k=int(input())
l=[int(input()) for i in range(k)]
s=0
ans=[0]*k
ans[0]=1
MOD=10**9+7
fact=[0]*(10**6+5)
fact[0]=1
for i in range(1,10**6+5):
fact[i]=(fact[i-1]*i)%MOD
#print(fact[0:10])
def c(n,k):
if k>=n:
return 1
if k==0 or k==n:
return 1
return fact[n]//(fact[k]*fact[n-k])%MOD
ans=1
sm=l[0]
for i in range(1,k):
curr=l[i]
#ans[i]=ans[i-1]+
ans=ans*(c(sm+curr-1,curr-1))
ans%=MOD
sm+=l[i]
print(ans)
``` | instruction | 0 | 90,527 | 7 | 181,054 |
No | output | 1 | 90,527 | 7 | 181,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
Submitted Solution:
```
from functools import reduce
from operator import mul
mod = 10 ** 9 + 7
k = int(input())
cs = [int(input()) for _ in range(k)]
cumcs = cs[:]
for i in range(1, len(cs)):
cumcs[i] += cumcs[i - 1]
def C(n, k):
num = reduce(mul, range(n, n - k, -1), 1)
denom = reduce(mul, range(k, 0, -1), 1)
return (num // denom) % mod
res = 1
for cum, c in zip(cumcs, cs):
res *= C(cum - 1, c - 1)
print(res)
``` | instruction | 0 | 90,528 | 7 | 181,056 |
No | output | 1 | 90,528 | 7 | 181,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
Submitted Solution:
```
from math import *
from collections import deque
from copy import deepcopy
import sys
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def multi(): return map(int,input().split())
def strmulti(): return map(str, inp().split())
def lis(): return list(map(int, inp().split()))
def lcm(a,b): return (a*b)//gcd(a,b)
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def stringlis(): return list(map(str, inp().split()))
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def printlist(a) :
print(' '.join(str(a[i]) for i in range(len(a))))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#copied functions end
#start coding
k=int(input())
ans=1
sum=0
for i in range(k):
num=int(input())
sum+=num
ans*=(ncr(sum-1,num-1))
# print(ans)
print(ans)
``` | instruction | 0 | 90,529 | 7 | 181,058 |
No | output | 1 | 90,529 | 7 | 181,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
Submitted Solution:
```
from sys import stdin,stdout
from collections import defaultdict
import math
#stdin = open('input.txt','r')
I = stdin.readline
P = stdout.write
k = int(I())
tot = 0
ans = 1
for i in range(k):
now = int(I())
ans*=math.factorial(tot+now-1)//math.factorial(tot)//math.factorial(now-1)
tot+=now
print(ans)
``` | instruction | 0 | 90,530 | 7 | 181,060 |
No | output | 1 | 90,530 | 7 | 181,061 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2 | instruction | 0 | 91,478 | 7 | 182,956 |
"Correct Solution:
```
h=int(input())
w=int(input())
n=int(input())
print(min(0--n//w,0--n//h))
``` | output | 1 | 91,478 | 7 | 182,957 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2 | instruction | 0 | 91,479 | 7 | 182,958 |
"Correct Solution:
```
h = int(input())
w = int(input())
n = int(input())
print(min(-(-n//h),-(-n//w)))
``` | output | 1 | 91,479 | 7 | 182,959 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2 | instruction | 0 | 91,480 | 7 | 182,960 |
"Correct Solution:
```
H = int(input())
W = int(input())
N = int(input())
u = max(H, W)
print(N // u + (N % u != 0))
``` | output | 1 | 91,480 | 7 | 182,961 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2 | instruction | 0 | 91,481 | 7 | 182,962 |
"Correct Solution:
```
from math import ceil
h = int(input())
w = int(input())
n = int(input())
print(ceil(n/max(h,w)))
``` | output | 1 | 91,481 | 7 | 182,963 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2 | instruction | 0 | 91,482 | 7 | 182,964 |
"Correct Solution:
```
import math
H=int(input())
W=int(input())
N=int(input())
a=max(H,W)
print(math.ceil(N/a))
``` | output | 1 | 91,482 | 7 | 182,965 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2 | instruction | 0 | 91,483 | 7 | 182,966 |
"Correct Solution:
```
H, W, N = int(input()), int(input()), int(input())
M = max(H, W)
print(N // M + (N % M != 0))
``` | output | 1 | 91,483 | 7 | 182,967 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2 | instruction | 0 | 91,484 | 7 | 182,968 |
"Correct Solution:
```
import math
a=int(input())
b=int(input())
x=int(input())
print(math.ceil(x/max(a,b)))
``` | output | 1 | 91,484 | 7 | 182,969 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2 | instruction | 0 | 91,485 | 7 | 182,970 |
"Correct Solution:
```
h=int(input())
w=int(input())
n=int(input())
m=max(h,w)
print(-(-n//m))
``` | output | 1 | 91,485 | 7 | 182,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2
Submitted Solution:
```
h = int(input())
w = int(input())
n = int(input())
print((n + max(h,w) - 1) // (max(h,w)))
``` | instruction | 0 | 91,486 | 7 | 182,972 |
Yes | output | 1 | 91,486 | 7 | 182,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2
Submitted Solution:
```
h = int(input())
w = int(input())
n = int(input())
s = max(h,w)
print((n+s-1)//s)
``` | instruction | 0 | 91,487 | 7 | 182,974 |
Yes | output | 1 | 91,487 | 7 | 182,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2
Submitted Solution:
```
H=int(input())
W=int(input())
N=int(input())
import math
print(math.ceil(N/(max(H,W))))
``` | instruction | 0 | 91,488 | 7 | 182,976 |
Yes | output | 1 | 91,488 | 7 | 182,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2
Submitted Solution:
```
import math
H,W,N=[int(input()) for i in range(3)]
print(math.ceil(N/max(H,W)))
``` | instruction | 0 | 91,489 | 7 | 182,978 |
Yes | output | 1 | 91,489 | 7 | 182,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2
Submitted Solution:
```
H = int(input())
W = int(input())
N = int(input())
ans = 0
num_bk = 0
for i in range(0,min(H,W)+1):
num_bk += max(H,W)
ans +=1
if num_bk>N:
print(ans)
break
``` | instruction | 0 | 91,490 | 7 | 182,980 |
No | output | 1 | 91,490 | 7 | 182,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2
Submitted Solution:
```
H=int(input())
W=int(input())
N=int(input())
if H<W:
H,W=W,H
ans = N // H
if N % H > 0: N += 1
print(ans)
``` | instruction | 0 | 91,491 | 7 | 182,982 |
No | output | 1 | 91,491 | 7 | 182,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2
Submitted Solution:
```
H=int(input())
W=int(input())
N=int(input())
if W>H :
if N%W==0:
k=N/W
else:
k=int(N/W)+1
else:
if N%H==0:
k=N/H
else:
k=int(N/H)+1
print(k)
``` | instruction | 0 | 91,492 | 7 | 182,984 |
No | output | 1 | 91,492 | 7 | 182,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns, where all the squares are initially white.
You will perform some number of painting operations on the grid. In one operation, you can do one of the following two actions:
* Choose one row, then paint all the squares in that row black.
* Choose one column, then paint all the squares in that column black.
At least how many operations do you need in order to have N or more black squares in the grid? It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.
Constraints
* 1 \leq H \leq 100
* 1 \leq W \leq 100
* 1 \leq N \leq H \times W
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H
W
N
Output
Print the minimum number of operations needed.
Examples
Input
3
7
10
Output
2
Input
14
12
112
Output
8
Input
2
100
200
Output
2
Submitted Solution:
```
H = int(input())
W = int(input())
N = int(input())
if H >= W:
if N//H != 0:print(N//H + 1)
else: print(N//H)
else:
if N//W != 0:print(N//W + 1)
else: print(N//W)
``` | instruction | 0 | 91,493 | 7 | 182,986 |
No | output | 1 | 91,493 | 7 | 182,987 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0 | instruction | 0 | 91,595 | 7 | 183,190 |
"Correct Solution:
```
from collections import defaultdict
H,W,N = map(int,input().split())
d = defaultdict(int)
for i in range(N):
a,b = map(int,input().split())
for dy in range(-1,2):
for dx in range(-1,2):
if a+dy >= 2 and a+dy <= H-1 and b+dx >= 2 and b+dx <= W-1:
d[(a+dy,b+dx)] += 1
ans = [0]*10
ans[0] = (H-2)*(W-2)-len(d)
for i in d.values():
ans[i] += 1
for i in ans:
print(i)
``` | output | 1 | 91,595 | 7 | 183,191 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0 | instruction | 0 | 91,596 | 7 | 183,192 |
"Correct Solution:
```
from collections import defaultdict
H,W,N = map(int,input().split())
AB = [list(map(int,input().split())) for _ in range(N)]
Cells = defaultdict(int)
Count = [(H-2)*(W-2)] + [0 for _ in range(9)]
for a,b in AB:
a -= 1
b -= 1
for i in range(-1,2):
for j in range(-1,2):
if 1 <= a+i <= H-2 and 1 <= b+j <= W-2:
Count[Cells[(a+i,b+j)]] -= 1
Count[Cells[(a+i,b+j)]+1] += 1
Cells[(a+i,b+j)] += 1
for c in Count:
print(c)
``` | output | 1 | 91,596 | 7 | 183,193 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0 | instruction | 0 | 91,597 | 7 | 183,194 |
"Correct Solution:
```
h,w,n=map(int,input().split())
d={}
for _ in range(n):
a,b=map(int,input().split())
for i in (-1,0,1):
for j in (-1,0,1):
if 2<=a+i<=h-1 and 2<=b+j<=w-1:
d.setdefault((a+i,b+j),0)
d[a+i,b+j]+=1
r=[0]*10
for i in d.values():
r[i]+=1
r[0]=(h-2)*(w-2)-sum(r)
for i in r:
print(i)
``` | output | 1 | 91,597 | 7 | 183,195 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0 | instruction | 0 | 91,598 | 7 | 183,196 |
"Correct Solution:
```
h,w,n = map(int,input().split())
grids = {}
D = [1,-1,0]
for _ in range(n):
a,b = map(int,input().split())
a -= 1
b -= 1
for dx in D:
for dy in D:
na,nb = a+dx,b+dy
if not(0<na<h-1 and 0<nb<w-1):
continue
if(na,nb) not in grids:
grids[(na,nb)] = 0
grids[(na,nb)] += 1
ans = [0 for _ in range(10)]
for v in grids.values():
ans[v]+=1
ans[0] = (h-2)*(w-2)-sum(ans)
for a in ans:
print(a)
``` | output | 1 | 91,598 | 7 | 183,197 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0 | instruction | 0 | 91,599 | 7 | 183,198 |
"Correct Solution:
```
from collections import defaultdict
h,w,n=map(int,input().split())
d=defaultdict(int)
s=set()
for _ in range(n):
a,b=map(int,input().split())
a-=1
b-=1
for dy in [-2,-1,0]:
for dx in [-2,-1,0]:
ny,nx=a+dy,b+dx
if 0<=ny<h and 0<=nx<w and ny+2<h and nx+2<w:
d[(ny,nx)]+=1
s.add((ny,nx))
cnt=[0]*10
q=0
for y,x in s:
cnt[d[(y,x)]]+=1
cnt[0]=(h-2)*(w-2)-len(s)
for i in cnt:
print(i)
``` | output | 1 | 91,599 | 7 | 183,199 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0 | instruction | 0 | 91,600 | 7 | 183,200 |
"Correct Solution:
```
from collections import Counter
h,w,n = map(int,input().split())
need = []
append = need.append
for i in range(n):
a,b = map(int,input().split())
for x in range(-2,1):
for y in range(-2,1):
s = a + x
t = b + y
if 1 <= s <= h-2 and 1 <= t <= w-2:
append(s*10**10 + t)
data = Counter(need).most_common()
ans = [0 for i in range(10)]
for x,y in data:
ans[y] += 1
print((h-2)*(w-2)-sum(ans))
for i in ans[1:]:
print(i)
``` | output | 1 | 91,600 | 7 | 183,201 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0 | instruction | 0 | 91,601 | 7 | 183,202 |
"Correct Solution:
```
from collections import defaultdict
h,w,n = map(int,input().split())
d = defaultdict(int)
for _ in range(n):
a,b = map(int,input().split())
for i in range(-1,2):
for j in range(-1,2):
if 1 < a+i < h and 1 < b+j < w:
d[(a+i,b+j)] += 1
ans = [0]*10
for i in d.values():
ans[i] += 1
ans[0] = (h-2)*(w-2)-sum(ans)
for i in ans:
print(i)
``` | output | 1 | 91,601 | 7 | 183,203 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0 | instruction | 0 | 91,602 | 7 | 183,204 |
"Correct Solution:
```
from collections import defaultdict
import sys
input = sys.stdin.readline
h,w,n = map(int,input().split())
d = defaultdict()
ans = [0]*10
for k in range(n):
a,b = map(int,input().split())
a -= 1
b -= 1
for i in range(-1,2):
for j in range(-1,2):
if (a+i,b+j) in d:
d[(a+i,b+j)] += 1
else:
d[(a+i,b+j)] = 1
for k,v in d.items():
if 0 < k[0] < h-1 and 0 < k[1] < w-1:
ans[v] += 1
ans[0] = (h-2) * (w-2) - sum(ans)
for i in ans:
print(i)
``` | output | 1 | 91,602 | 7 | 183,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0
Submitted Solution:
```
H,W,N=map(int,input().split())
direc=[[0,0],[-1,0],[-2,0],[0,-1],[-1,-1],[-2,-1],[0,-2],[-1,-2],[-2,-2]]
dic={}
for i in range(N):
h,w=map(int,input().split())
for d in direc:
if 1<=h+d[0]<=(H-2) and 1<=w+d[1]<=(W-2):
l=(h+d[0],w+d[1])
if l in dic:
dic[l]=dic[l]+1
else:
dic[l]=1
A=list(dic.values())
print((H-2)*(W-2)-len(A))
for i in range(1,10):
print(A.count(i))
``` | instruction | 0 | 91,603 | 7 | 183,206 |
Yes | output | 1 | 91,603 | 7 | 183,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0
Submitted Solution:
```
from itertools import product
from collections import Counter
H, W, N = map(int, input().split())
V = set([tuple(map(int, input().split())) for _ in range(N)])
D = tuple(product((-1, 0, 1), repeat=2))
A = set()
cnt = Counter()
for a, b in V:
for h, w in D:
if 2 <= a + h <= H - 1 and 2 <= b + w <= W - 1:
cnt[(a + h, b + w)] += 1
ans = [0] * 10
for c in cnt.values():
ans[c] += 1
ans[0] = (H - 2) * (W - 2) - sum(ans)
print(*ans, sep='\n')
``` | instruction | 0 | 91,604 | 7 | 183,208 |
Yes | output | 1 | 91,604 | 7 | 183,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0
Submitted Solution:
```
H,W,N = map(int,input().split())
count = []
L = 0
for i in range(N):
a,b = map(int, input().split())
a -= 1
b -= 1
for i in range(max(0,a-2),min(a+1,H-2)):
for j in range(max(0,b-2),min(b+1,W-2)):
count.append((i,j))
L += 1
count.sort()
ans = [0]*10
tmp = 1
for i in range(L-1):
if count[i] == count[i+1]:
tmp += 1
else:
ans[tmp] += 1
tmp = 1
if L>=1:
ans[tmp] += 1
ans[0] = (H-2)*(W-2)-sum(ans)
for i in range(10):
print(ans[i])
``` | instruction | 0 | 91,605 | 7 | 183,210 |
Yes | output | 1 | 91,605 | 7 | 183,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0
Submitted Solution:
```
from collections import *
h,w,n = map(int,input().split())
dic = defaultdict(int)
for _ in range(n):
a,b = map(int,input().split())
for i in range(9):
dic[a - i //3,b - i % 3] += 1
ans =[0]*10
for i, j in dic:
ans[dic[i,j]] += h-1 > i > 0 < j < w -1
ans[0] = (h -2)*(w-2) - sum(ans)
for item in ans:
print(item)
``` | instruction | 0 | 91,606 | 7 | 183,212 |
Yes | output | 1 | 91,606 | 7 | 183,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0
Submitted Solution:
```
from collections import *
h,w,n = map(int,input().split())
dic = defaultdict(int)
for _ in range(n):
a,b = map(int,input().split())
for i in range(9):
dic[a - i //3,b - i % 3] += 1
ans =[0]*(n+1)
for i, j in dic:
ans[dic[i,j]] += h-1 > i > 0 < j < w -1
ans[0] = (h -2)*(w-2) - sum(ans)
print(*ans)
``` | instruction | 0 | 91,607 | 7 | 183,214 |
No | output | 1 | 91,607 | 7 | 183,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0
Submitted Solution:
```
H,W,N=map(int,input().split())
ab=[list(map(int,input().split())) for i in range(N)]
ab.sort()
r_b=[0]
rows=[]
rows_app=rows.append
r_b_app=r_b.append
for i in range(1,N):
if ab[i][0]!=ab[i-1][0]:
r_b_app(i)
rows_app(ab[i-1][0])
if N>0:
rows.append(ab[N-1][0])
r_b.append(N)
cols=[[ab[j][1] for j in range(r_b[i],r_b[i+1])] for i in range(len(r_b)-1)]
rN=len(cols)
ched_box=[[[[False]*3 for k in range(3)] for j in range((len(cols[i]) if i<rN else 0))] for i in range(3)]
dic_cn=[dict(zip(cols[i],list(range(len(cols[i]))))) if i<rN else {} for i in range(3)]
area_n=[0]*9
count=[[1]*3 for i in range(3)]
find_cn=[0]*12
for rn in range(rN):
cN=len(cols[rn])
row=rows[rn]
if rn!=0:
ched_box[0]=ched_box[1]
dic_cn[0]=dic_cn[1]
ched_box[1]=ched_box[2]
dic_cn[1]=dic_cn[2]
if rn<rN-2:
ched_box[2]=[[[False]*3 for k in range(3)] for j in range(len(cols[rn+2]))]
dic_cn[2]=dict(zip(cols[rn+2],list(range(len(cols[rn+2])))))
if (rows[rn+1]==row+1 if rn<rN-1 else False):
row1=row+1
if (rows[rn+2]==row+2 if rn<rN-2 else False):
row2=row+2
else:
row2=None
elif (rows[rn+1]==row+2 if rn<rN-1 else False):
row1=row+2
row2=None
else:
row1=None
row2=None
for cn in range(cN):
col=cols[rn][cn]
for box_row in range(3):
for box_col in range(3):
if col-2+box_col<1 or col+box_col>W or row-2+box_row<1 or row+box_row>H:
ched_box[0][cn][box_row][box_col]=True
find_rowcol=[]
find_rowcol_app=find_rowcol.append
find_cn_n=0
for ch_row in range(row,min(row+3,H+1)):
if ch_row==row:
for ch_col in range(col+1,min(col+3,W+1)):
if ch_col in dic_cn[0]:
find_rowcol_app([row,ch_col])
find_cn[find_cn_n]=dic_cn[0][ch_col]
find_cn_n+=1
elif ch_row==row1:
for ch_col in range(max(col-2,1),min(col+3,W+1)):
if ch_col in dic_cn[1]:
find_rowcol_app([row1,ch_col])
find_cn[find_cn_n]=dic_cn[1][ch_col]
find_cn_n+=1
elif ch_row==row2:
for ch_col in range(max(col-2,1),min(col+3,W+1)):
if ch_col in dic_cn[2]:
find_rowcol_app([row2,ch_col])
find_cn[find_cn_n]=dic_cn[2][ch_col]
find_cn_n+=1
ch_box_row_col=[]
for i,[find_row,find_col] in enumerate(find_rowcol):
if find_row==row:
ch_rn=0
ch_cn=find_cn[i]
elif find_row==row1:
ch_rn=1
ch_cn=find_cn[i]
elif find_row==row2:
ch_rn=2
ch_cn=find_cn[i]
for box_row in range(find_row-row,3):
for box_col in range(max(find_col-col,0),min(3,3+find_col-col)):
if not ched_box[0][cn][box_row][box_col]:
count[box_row][box_col]+=1
ched_box[ch_rn][ch_cn][box_row-find_row+row][box_col-find_col+col]=True
for box_row in range(3):
for box_col in range(3):
if not ched_box[0][cn][box_row][box_col]:
area_n[count[box_row][box_col]-1]+=1
count[box_row][box_col]=1
print((W-2)*(H-2)-sum(area_n))
for i in range(9):
print(area_n[i])
``` | instruction | 0 | 91,608 | 7 | 183,216 |
No | output | 1 | 91,608 | 7 | 183,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with H rows and W columns. At first, all cells were painted white.
Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.
Compute the following:
* For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?
Constraints
* 3 \leq H \leq 10^9
* 3 \leq W \leq 10^9
* 0 \leq N \leq min(10^5,H×W)
* 1 \leq a_i \leq H (1 \leq i \leq N)
* 1 \leq b_i \leq W (1 \leq i \leq N)
* (a_i, b_i) \neq (a_j, b_j) (i \neq j)
Input
The input is given from Standard Input in the following format:
H W N
a_1 b_1
:
a_N b_N
Output
Print 10 lines. The (j+1)-th ( 0 \leq j \leq 9 ) line should contain the number of the subrectangles of size 3×3 of the grid that contains exactly j black cells.
Examples
Input
4 5 8
1 1
1 4
1 5
2 3
3 1
3 2
3 4
4 4
Output
0
0
0
2
4
0
0
0
0
0
Input
10 10 20
1 1
1 4
1 9
2 5
3 10
4 2
4 7
5 9
6 4
6 6
6 7
7 1
7 3
7 7
8 1
8 5
8 10
9 2
10 4
10 9
Output
4
26
22
10
2
0
0
0
0
0
Input
1000000000 1000000000 0
Output
999999996000000004
0
0
0
0
0
0
0
0
0
Submitted Solution:
```
import collections
from itertools import product
H, W, N = map(int,input().split())
PaintList = []
pat = list(product((-2,-1,0),repeat=2))
for i in range(N):
x,y = map(int, input().split())
for p in pat:
xw = x + p[0]
yw = y + p[1]
#print(xw,yw)
if 1 <= xw <= H-2 and 1 <= yw <= W-2:
PaintList.append((xw,yw))
c = collections.Counter(PaintList)
#print(c)
ans = [0] * 10
for k,v in c.items():
if k[0] <= H-2 and k[1] <= W-2:
ans[v] += 1
ans[0] = (H-2)*(W-2) - sum(ans[1:9])
for i in range(10):
print(ans[i])
``` | instruction | 0 | 91,609 | 7 | 183,218 |
No | output | 1 | 91,609 | 7 | 183,219 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.