submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s905083699 | p00026 | Wrong Answer | cell = [[0] * 10 for i in xrange(10)]
large = [[0,0,1,0,0],
[0,1,1,1,0],
[1,1,1,1,1],
[0,1,1,1,0],
[0,0,1,0,0]]
medium= [[0,0,0,0,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,0,0,0,0]]
small = [[0,0,0,0,0],
[0,0,1,0,0],
[0,1,1,1,0],
[0,0,1,0,0],
[0,0,0,0,0]]
size = [0,small,medium,large]
while True:
try:
x, y, s = [int(i) for i in raw_input().split(',')]
except EOFError:
break
except ValueError:
break
p = size[s]
for i in xrange(5):
for j in xrange(5):
try:
cell[i+x][j+y] += p[i+2][j+2]
except IndexError:
pass
print reduce(lambda x,y:x+y,map(lambda x:x.count(0),cell))
print max(map(max,cell)) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s446500078 | p00026 | Wrong Answer | cell = [[0] * 10 for i in xrange(10)]
large = [[0,0,1,0,0],
[0,1,1,1,0],
[1,1,1,1,1],
[0,1,1,1,0],
[0,0,1,0,0]]
medium= [[0,0,0,0,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,0,0,0,0]]
small = [[0,0,0,0,0],
[0,0,1,0,0],
[0,1,1,1,0],
[0,0,1,0,0],
[0,0,0,0,0]]
size = [0,small,medium,large]
while True:
try:
x, y, s = [int(i) for i in raw_input().split(',')]
except EOFError:
break
except ValueError:
break
p = size[s]
for i in xrange(5):
for j in xrange(5):
try:
cell[i+y-2][j+x-2] += p[i][j]
except IndexError:
pass
print cell
print reduce(lambda x,y:x+y,map(lambda x:x.count(0),cell))
print max(map(max,cell)) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s910631089 | p00026 | Wrong Answer | from __future__ import (absolute_import, division, print_function,
unicode_literals)
from sys import stdin
from collections import Counter
NUM = [[0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0],
[0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
paper = Counter()
for line in stdin:
if not line.strip():
break
x, y, size = (int(s) for s in line.split(','))
xidx = [x, x-1, x, x+1, x-2, x-1, x, x+1, x+2, x-1, x, x+1, x]
yidx = [y-2, y-1, y-1, y-1, y, y, y, y, y, y+1, y+1, y+1, y+2]
val = iter(NUM[size-1])
for x, y in zip(xidx, yidx):
paper[x + y * 10] += next(val)
print(sum(1 for i in xrange(100) if not paper[i]))
print(max(paper[i] for i in xrange(100))) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s868049263 | p00026 | Wrong Answer | from __future__ import (absolute_import, division, print_function,
unicode_literals)
from sys import stdin
from collections import Counter
NUM = [[0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0],
[0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
paper = Counter()
for line in stdin:
if not line.strip():
break
x, y, size = (int(s) for s in line.split(','))
xidx = [x, x-1, x, x+1, x-2, x-1, x, x+1, x+2, x-1, x, x+1, x]
yidx = [y-2, y-1, y-1, y-1, y, y, y, y, y, y+1, y+1, y+1, y+2]
val = iter(NUM[size-1])
for a, b in zip(xidx, yidx):
if a < 0 or 9 < a or b < 0 or 9 < b:
continue
paper[a + b * 10] += next(val)
for y in xrange(10):
for x in xrange(10):
print('{:02d} '.format(paper[x + y * 10]), end='')
print()
print(sum(1 for i in xrange(100) if not paper[i]))
print(max(paper[i] for i in xrange(100))) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s294954272 | p00026 | Wrong Answer | mass = [[0 for p in xrange(14)] for q in xrange(14)]
while True:
try:
x,y,size = map(int,raw_input().split(','))
if size == 1:
mass[x-2][y-2]+=0;mass[x-1][y-2]+=0;mass[x][y-2]+=0;mass[x+1][y-2]+=0;mass[x+2][y-2]+=0
mass[x-2][y-1]+=0;mass[x-1][y-1]+=0;mass[x][y-1]+=1;mass[x+1][y-1]+=0;mass[x+2][y-1]+=0
mass[x-2][y] +=0;mass[x-1][y] +=1;mass[x][y] +=1;mass[x+1][y] +=1;mass[x+2][y] +=0
mass[x-2][y+1]+=0;mass[x-1][y+1]+=0;mass[x][y+1]+=1;mass[x+1][y+1]+=0;mass[x+2][y+1]+=0
mass[x-2][y+2]+=0;mass[x-1][y+2]+=0;mass[x][y+2]+=0;mass[x+1][y+2]+=0;mass[x+2][y+2]+=0
elif size == 2:
mass[x-2][y-2]+=0;mass[x-1][y-2]+=0;mass[x][y-2]+=0;mass[x+1][y-2]+=0;mass[x+2][y-2]+=0
mass[x-2][y-1]+=0;mass[x-1][y-1]+=1;mass[x][y-1]+=1;mass[x+1][y-1]+=1;mass[x+2][y-1]+=0
mass[x-2][y] +=0;mass[x-1][y] +=1;mass[x][y] +=1;mass[x+1][y] +=1;mass[x+2][y] +=0
mass[x-2][y+1]+=0;mass[x-1][y+1]+=1;mass[x][y+1]+=1;mass[x+1][y+1]+=1;mass[x+2][y+1]+=0
mass[x-2][y+2]+=0;mass[x-1][y+2]+=0;mass[x][y+2]+=0;mass[x+1][y+2]+=0;mass[x+2][y+2]+=0
elif size == 3:
mass[x-2][y-2]+=0;mass[x-1][y-2]+=0;mass[x][y-2]+=1;mass[x+1][y-2]+=0;mass[x+2][y-2]+=0
mass[x-2][y-1]+=0;mass[x-1][y-1]+=1;mass[x][y-1]+=1;mass[x+1][y-1]+=1;mass[x+2][y-1]+=0
mass[x-2][y] +=1;mass[x-1][y] +=1;mass[x][y] +=1;mass[x+1][y] +=1;mass[x+2][y] +=1
mass[x-2][y+1]+=0;mass[x-1][y+1]+=1;mass[x][y+1]+=1;mass[x+1][y+1]+=1;mass[x+2][y+1]+=0
mass[x-2][y+2]+=0;mass[x-1][y+2]+=0;mass[x][y+2]+=1;mass[x+1][y+2]+=0;mass[x+2][y+2]+=0
except: break
white = 0
max = 0
for p in xrange(2,12):
for val in xrange(2,12):
if mass[p][q] == 0: white += 1
if mass[p][q] > max: max = mass[p][q]
print white
print max | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s311322157 | p00026 | Wrong Answer | mass = [[0 for p in xrange(14)] for q in xrange(14)]
while True:
try:
x,y,size = map(int,raw_input().split(','))
x += 2 ; y += 2
if size == 1:
mass[x-2][y-2]+=0;mass[x-1][y-2]+=0;mass[x][y-2]+=0;mass[x+1][y-2]+=0;mass[x+2][y-2]+=0
mass[x-2][y-1]+=0;mass[x-1][y-1]+=0;mass[x][y-1]+=1;mass[x+1][y-1]+=0;mass[x+2][y-1]+=0
mass[x-2][y] +=0;mass[x-1][y] +=1;mass[x][y] +=1;mass[x+1][y] +=1;mass[x+2][y] +=0
mass[x-2][y+1]+=0;mass[x-1][y+1]+=0;mass[x][y+1]+=1;mass[x+1][y+1]+=0;mass[x+2][y+1]+=0
mass[x-2][y+2]+=0;mass[x-1][y+2]+=0;mass[x][y+2]+=0;mass[x+1][y+2]+=0;mass[x+2][y+2]+=0
elif size == 2:
mass[x-2][y-2]+=0;mass[x-1][y-2]+=0;mass[x][y-2]+=0;mass[x+1][y-2]+=0;mass[x+2][y-2]+=0
mass[x-2][y-1]+=0;mass[x-1][y-1]+=1;mass[x][y-1]+=1;mass[x+1][y-1]+=1;mass[x+2][y-1]+=0
mass[x-2][y] +=0;mass[x-1][y] +=1;mass[x][y] +=1;mass[x+1][y] +=1;mass[x+2][y] +=0
mass[x-2][y+1]+=0;mass[x-1][y+1]+=1;mass[x][y+1]+=1;mass[x+1][y+1]+=1;mass[x+2][y+1]+=0
mass[x-2][y+2]+=0;mass[x-1][y+2]+=0;mass[x][y+2]+=0;mass[x+1][y+2]+=0;mass[x+2][y+2]+=0
elif size == 3:
mass[x-2][y-2]+=0;mass[x-1][y-2]+=0;mass[x][y-2]+=1;mass[x+1][y-2]+=0;mass[x+2][y-2]+=0
mass[x-2][y-1]+=0;mass[x-1][y-1]+=1;mass[x][y-1]+=1;mass[x+1][y-1]+=1;mass[x+2][y-1]+=0
mass[x-2][y] +=1;mass[x-1][y] +=1;mass[x][y] +=1;mass[x+1][y] +=1;mass[x+2][y] +=1
mass[x-2][y+1]+=0;mass[x-1][y+1]+=1;mass[x][y+1]+=1;mass[x+1][y+1]+=1;mass[x+2][y+1]+=0
mass[x-2][y+2]+=0;mass[x-1][y+2]+=0;mass[x][y+2]+=1;mass[x+1][y+2]+=0;mass[x+2][y+2]+=0
except: break
white = 0
max = 0
for p in xrange(2,12):
for val in xrange(2,12):
if mass[p][q] == 0: white += 1
if mass[p][q] > max: max = mass[p][q]
print white
print max | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s727148516 | p00026 | Wrong Answer |
import sys
class Paper:
def __init__(self):
self.paper = [[0 for x in range(10)] for y in range(10)]
def white_space(self):
s = 0
for x in range(10):
for y in range(10):
if self.paper[x][y] == 0:
s += 1
return s
def most_dark(self):
s = 0
for x in range(10):
for y in range(10):
if self.paper[x][y] > s:
s = self.paper[x][y]
return s
def drop(self, x, y, size):
r = []
if size == 1:
r.append((x,y))
r.append((x-1,y))
r.append((x+1,y))
r.append((x,y-1))
r.append((x,y+1))
elif size == 2:
r = [(i,j) for i in range(x-1, x+2) for j in range(y-1, y+2)]
elif size == 3:
r = [(i,j) for i in range(x-1, x+2) for j in range(y-1, y+2)]
r.append((x-2, y))
r.append((x+2, y))
r.append((x, y-2))
r.append((x, y+2))
else:
pass
try:
for p in r:
self.paper[p[0]][p[1]] += 1
except:
pass
return self
#input_file = open(sys.argv[1], 'r')
paper = Paper()
for line in sys.stdin:
(x, y, size) = tuple(map(int, line.split(',')))
paper.drop(x, y, size)
print paper.white_space()
print paper.most_dark() | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s699133676 | p00026 | Wrong Answer |
import sys
class Paper:
def __init__(self):
self.paper = [[0 for x in range(10)] for y in range(10)]
def white_space(self):
s = 0
for x in range(10):
for y in range(10):
if self.paper[x][y] == 0:
s += 1
return s
def most_dark(self):
s = 0
for x in range(10):
for y in range(10):
if self.paper[x][y] > s:
s = self.paper[x][y]
return s
def drop(self, x, y, size):
r = []
if size == 1:
r.append((x,y))
r.append((x-1,y))
r.append((x+1,y))
r.append((x,y-1))
r.append((x,y+1))
elif size == 2:
r = [(i,j) for i in range(x-1, x+2) for j in range(y-1, y+2)]
elif size == 3:
r = [(i,j) for i in range(x-1, x+2) for j in range(y-1, y+2)]
r.append((x-2, y))
r.append((x+2, y))
r.append((x, y-2))
r.append((x, y+2))
else:
pass
r = filter(self.out_of_paper, r)
try:
for p in r:
self.paper[p[0]][p[1]] += 1
except:
pass
return self
def out_of_paper(self, p):
if p[0] >= 0 and p[1] >= 0:
True
else:
False
#input_file = open(sys.argv[1], 'r')
paper = Paper()
for line in sys.stdin:
(x, y, size) = tuple(map(int, line.split(',')))
paper.drop(x, y, size)
print paper.white_space()
print paper.most_dark() | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s948987818 | p00026 | Wrong Answer |
import sys
class Paper:
def __init__(self):
self.paper = [[0 for x in range(10)] for y in range(10)]
def white_space(self):
s = 0
for x in range(10):
for y in range(10):
if self.paper[x][y] == 0:
s += 1
return s
def most_dark(self):
s = 0
for x in range(10):
for y in range(10):
if self.paper[x][y] > s:
s = self.paper[x][y]
return s
def drop(self, x, y, size):
r = []
if size == 1:
r.append((x,y))
r.append((x-1,y))
r.append((x+1,y))
r.append((x,y-1))
r.append((x,y+1))
elif size == 2:
r = [(i,j) for i in range(x-1, x+2) for j in range(y-1, y+2)]
elif size == 3:
r = [(i,j) for i in range(x-1, x+2) for j in range(y-1, y+2)]
r.append((x-2, y))
r.append((x+2, y))
r.append((x, y-2))
r.append((x, y+2))
else:
pass
r = filter(self.out_of_paper, r)
try:
for p in r:
self.paper[p[0]][p[1]] += 1
except:
pass
return self
def out_of_paper(self, p):
if 0 <= p[0] < 10 and 0 <= p[1] < 10:
True
else:
False
paper = Paper()
for line in sys.stdin:
(x, y, size) = tuple(map(int, line.split(',')))
paper.drop(x, y, size)
print paper.white_space()
print paper.most_dark() | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s315927474 | p00026 | Wrong Answer | def drop(x,y):
global paper
if 0<=x<10 and 0<=y<10: paper[y][x]+=1
return
def ink(x,y,size):
drop(x-1,y)
drop(x+1,y)
drop(x,y-1)
drop(x,y+1)
if size==1: return
drop(x-1,y-1)
drop(x-1,y+1)
drop(x+1,y-1)
drop(x+1,y+1)
if size==2: return
drop(x-2,y)
drop(x+2,y)
drop(x,y-2)
drop(x,y+2)
return
paper = [[0 for i in range(10)] for j in range(10)]
while True:
try:
x,y,size = map(int, raw_input().split(","))
ink(x,y,size)
except:
break
print sum([e.count(0) for e in paper])
print max([max(e) for e in paper]) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s695667626 | p00026 | Wrong Answer | import sys
SIZE = 10
paper = []
def main():
init()
for line in sys.stdin:
data = line.strip().split(',')
i = int(data[0])
j = int(data[1])
size = int(data[2])
if size == 1:
drop_small(i, j)
elif size == 2:
drop_medium(i, j)
elif size == 3:
drop_large(i, j)
print str(count_white()) + " " + str(find_max())
def find_max():
mx = 0
for i in xrange(SIZE):
for j in xrange(SIZE):
mx = max(mx, paper[i][j])
return mx
def count_white():
c = 0
for i in xrange(SIZE):
for j in xrange(SIZE):
if paper[i][j] == 0:
c += 1
return c
def init():
global paper
for i in xrange(SIZE):
paper.append([0]*SIZE)
def check(i, j):
if i < 0 or SIZE <= i:
return False
if j < 0 or SIZE <= j:
return False
return True
def drop(i, j):
global paper
if not check(i, j):
return False
paper[i][j] += 1
return True
def drop_small(i, j):
drop(i, j)
drop(i - 1, j)
drop(i + 1, j)
drop(i, j - 1)
drop(i, j + 1)
def drop_medium(i, j):
drop_small(i, j)
drop(i - 1, j - 1)
drop(i - 1, j + 1)
drop(i + 1, j - 1)
drop(i + 1, j + 1)
def drop_large(i, j):
drop_medium(i, j)
drop(i - 2, j)
drop(i, j - 2)
drop(i, j + 2)
drop(i + 2, j)
main() | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s051622048 | p00026 | Wrong Answer | paper = [[0 for i in range(14)] for i in range(14)]
while True:
try:
x, y, s = map(int, raw_input())
x += 2
y += 2
if s == 1:
paper[x][y] += 1
for i in range(-1,1,2):
paper[x+i][y] += 1
paper[x][y+1] += 1
elif s == 2:
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
else:
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
paper[x+2][y] += 1; paper[x-2][y] += 1
paper[x][y+2] += 1; paper[x][y-2] += 1
except:
break
white = 0
for i in range(2,11):
for j in range(2,11):
if paper[i][j] == 0:
white += 1
print white
print max(paper) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s567816899 | p00026 | Wrong Answer | paper = [[0 for i in range(14)] for i in range(14)]
while True:
try:
x, y, s = map(int, raw_input())
x += 2
y += 2
if s == 1:
paper[x][y] += 1
for i in range(-1,1,2):
paper[x+i][y] += 1
paper[x][y+1] += 1
elif s == 2:
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
else:
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
paper[x+2][y] += 1; paper[x-2][y] += 1
paper[x][y+2] += 1; paper[x][y-2] += 1
except:
break
white = 0
for i in range(2,13):
for j in range(2,13):
if paper[i][j] == 0:
white += 1
print white
print max(paper) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s087920903 | p00026 | Wrong Answer | #use 14x14 paper
paper = [[0 for i in range(14)] for i in range(14)]
while True:
try:
x, y, s = map(int, raw_input().split(","))
x += 2
y += 2
if s == 1:
paper[x][y] += 1
for i in range(-1,2,2):
paper[x+i][y] += 1
paper[x][y+1] += 1
elif s == 2:
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
else:
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
paper[x+2][y] += 1; paper[x-2][y] += 1
paper[x][y+2] += 1; paper[x][y-2] += 1
except:
break
#count white and check max paper element
white = 0
max = 0
for i in range(2,12):
for j in range(2,12):
if paper[i][j] == 0:
white += 1
else:
if paper[i][j] > max:
max = paper[i][j]
print white
print max | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s893458426 | p00026 | Wrong Answer | #use 14x14 paper
paper = [[0 for i in range(14)] for i in range(14)]
while True:
try:
x, y, s = map(int, raw_input().split(","))
x += 2; y += 2
if s == 1:
paper[x][y] += 1
for i in range(-1,2,2):
paper[x+i][y] += 1
paper[x][y+1] += 1
elif s == 2:
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
else:
paper[x+2][y] += 1; paper[x-2][y] += 1
paper[x][y+2] += 1; paper[x][y-2] += 1
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
except:
break
#count white and check max element in paper
white = 0
max = 0
for i in range(2,12):
for j in range(2,12):
if paper[i][j] == 0:
white += 1
elif paper[i][j] > max:
max = paper[i][j]
print white
print max | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s785253827 | p00026 | Wrong Answer | #use 14x14 paper
paper = [[0 for i in range(14)] for i in range(14)]
while True:
try:
x, y, s = map(int, raw_input().split(","))
x += 2; y += 2
if s == 1:
paper[x][y] += 1
for i in range(-1,2,2):
paper[x+i][y] += 1
paper[x][y+1] += 1
elif s == 2:
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
else:
paper[x+2][y] += 1; paper[x-2][y] += 1
paper[x][y+2] += 1; paper[x][y-2] += 1
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
except:
break
#count white and check max element in paper
white = 0
max = 0
for i in range(2,12):
for j in range(2,12):
if paper[i][j] == 0:
white += 1
elif paper[i][j] > max:
max = paper[i][j]
print "%d" % (white)
print "%d" % (max) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s909625293 | p00026 | Wrong Answer | #use 14x14 paper
paper = [[0 for i in range(14)] for i in range(14)]
while True:
try:
x, y, s = map(int, raw_input().split(","))
x += 2; y += 2
if s == 1:
paper[x][y] += 1
for i in range(-1,2,2):
paper[x+i][y] += 1
paper[x][y+1] += 1
elif s == 2:
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
else:
paper[x+2][y] += 1; paper[x-2][y] += 1
paper[x][y+2] += 1; paper[x][y-2] += 1
for i in range(-1,2):
for j in range(-1,2):
paper[x+i][y+j] += 1
except:
break
#count white and check max element in paper
white = 0
max = 0
for i in range(3,13):
for j in range(3,13):
if paper[i][j] == 0:
white += 1
elif paper[i][j] > max:
max = paper[i][j]
print "%d" % (white)
print "%d" % (max) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s576593094 | p00026 | Wrong Answer | def drop(x,y):
if 0 <= x < 10 and 0<= y < 10:
paper[y][x] += 1
return
def ink(x,y,s):
drop(x,y)
drop(x+1,y); drop(x,y+1)
drop(x-1,y); drop(x,y-1)
if s == 1: return
drop(x+1,y+1); drop(x+1,y-1)
drop(x-1,y+1); drop(x-1,y-1)
if s == 2: return
drop(x+2,y); drop(x,y+2)
drop(x-2,y); drop(x,y-2)
return
while True:
try:
x, y, s = map(int, raw_input().split(","))
ink(x,y,s)
except:
break | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s932723756 | p00026 | Wrong Answer | def drop(x,y):
global paper
if 0 <= x < 10 and 0<= y < 10:
paper[y][x] += 1
return
def ink(x,y,s):
drop(x,y)
drop(x+1,y); drop(x,y+1)
drop(x-1,y); drop(x,y-1)
if s == 1: return
drop(x+1,y+1); drop(x+1,y-1)
drop(x-1,y+1); drop(x-1,y-1)
if s == 2: return
drop(x+2,y); drop(x,y+2)
drop(x-2,y); drop(x,y-2)
return
while True:
try:
x, y, s = map(int, raw_input().split(","))
ink(x,y,s)
except:
break | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s712345619 | p00026 | Wrong Answer | paper = [[0 for i in range(10)] for i in range(10)]
def drop(x,y):
global paper
if 0 <= x < 10 and 0<= y < 10:
paper[y][x] += 1
return
def ink(x,y,s):
drop(x,y)
drop(x+1,y); drop(x,y+1)
drop(x-1,y); drop(x,y-1)
if s == 1: return
drop(x+1,y+1); drop(x+1,y-1)
drop(x-1,y+1); drop(x-1,y-1)
if s == 2: return
drop(x+2,y); drop(x,y+2)
drop(x-2,y); drop(x,y-2)
return
while True:
try:
x, y, s = map(int, raw_input().split(","))
ink(x,y,s)
except:
break | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s730391508 | p00026 | Wrong Answer | import sys
def ink(x,y,size):
global paper
paper[y][x]+=1
for d in [-1,1]:
paper[y+d][x]+=1
paper[y][x+d]+=1
if size==1: return
paper[y+d][x+d]+=1
paper[y+d][x-d]+=1
if size==2: return
for d in [-2,2]:
paper[y+d][x]+=1
paper[y][x+d]+=1
return
R=range(14)
paper=[[0 for i in R] for j in R]
for s in sys.stdin:
x,y,size = map(int, s.split(","))
ink(x+2,y+2,size)
c=0
m=0
for e in paper[2:-2]:
x=e[2:-2]
c+=x.count(0)
m=max(max(x),m)
print c
print m | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s928916753 | p00026 | Wrong Answer | small_x = [0, 0, 1, -1]
small_y = [-1, 1, 0, 0]
middle_x = [-1, -1, -1, 0, 0, 1, 1, 1]
middle_y = [-1, 0, 1, -1, 1, -1, 0, 1]
big_x = [-2, -1, -1, -1, 0, 0, 0, 0, 0, 1, 1, 1, 2]
big_y = [0, -1, 0, 1, -2, -1, 0, 1, 2, -1, 0, 1, 0]
dx = [[], small_x, middle_x, big_x]
dy = [[], small_y, middle_y, big_y]
field = [[0] * 10 for _ in range(10)]
while 1:
try:
x1, y1, size = map(int, raw_input().split(','))
for k in range(len(dx[size])):
nx = x1 + dx[size][k]
ny = y1 + dy[size][k]
if nx < 0 or ny < 0 or nx >= len(dx[size]) or ny >= len(dx[size]):
continue
field[ny][nx] = 1
except:
break
print sum(1 for i in range(10) for j in range(10) if field[i][j] == 0) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s527395184 | p00026 | Wrong Answer | small_x = [0, 0, 1, -1]
small_y = [-1, 1, 0, 0]
middle_x = [-1, -1, -1, 0, 0, 1, 1, 1]
middle_y = [-1, 0, 1, -1, 1, -1, 0, 1]
big_x = [-2, -1, -1, -1, 0, 0, 0, 0, 0, 1, 1, 1, 2]
big_y = [0, -1, 0, 1, -2, -1, 0, 1, 2, -1, 0, 1, 0]
dx = [[], small_x, middle_x, big_x]
dy = [[], small_y, middle_y, big_y]
field = [[0] * 10 for _ in range(10)]
while 1:
try:
x1, y1, size = map(int, raw_input().split(','))
for k in range(len(dx[size])):
nx = x1 + dx[size][k]
ny = y1 + dy[size][k]
if nx < 0 or ny < 0 or nx >= len(dx[size]) or ny >= len(dx[size]):
continue
field[ny][nx] += 1
except:
break
ret, mx = 0, 0
for i in range(10):
for j in range(10):
if field[i][j] == 0:
ret += 1
mx = max(mx, field[i][j])
print ret
print mx | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s984761202 | p00026 | Accepted | peper=[[0 for i in range(14)]for j in range(14)]
while True:
try:
x,y,s=map(int,input().split(","))
x +=2
y +=2
if s==3:
peper[y][x] +=1
peper[y][x-1] +=1
peper[y][x-2] +=1
peper[y][x+1] +=1
peper[y][x+2] +=1
peper[y-1][x] +=1
peper[y-2][x] +=1
peper[y+1][x] +=1
peper[y+2][x] +=1
peper[y-1][x-1] +=1
peper[y-1][x+1] +=1
peper[y+1][x-1] +=1
peper[y+1][x+1] +=1
elif s==2:
peper[y][x] +=1
peper[y][x+1] +=1
peper[y][x-1] +=1
peper[y+1][x] +=1
peper[y+1][x+1] +=1
peper[y+1][x-1] +=1
peper[y-1][x] +=1
peper[y-1][x+1] +=1
peper[y-1][x-1] +=1
elif s==1:
peper[y][x] +=1
peper[y+1][x] +=1
peper[y-1][x] +=1
peper[y][x+1] +=1
peper[y][x-1] +=1
except:
co=0
ma=0
for i in range(2,12):
for j in range(2,12):
if peper[i][j]==0:
co +=1
else:
ma=max(ma,peper[i][j])
print(co)
print(ma)
break
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s083529398 | p00026 | Accepted | #!/usr/bin/python
paper = [[0] * 10 for i in range(10)]
def small(x, y):
p = [[x, y]]
for i, j in zip([-1, 0, 1, 0], [0, -1, 0, 1]):
p.append([x + i, y + j])
return p
def middle(x, y):
p = small(x, y)
for i, j in zip([1, -1, 1, -1], [1, 1, -1, -1]):
p.append([x + i, y + j])
return p
def big(x, y):
p = middle(x, y)
for i, j in zip([-2, 0, 2, 0], [0, -2, 0, 2]):
p.append([x + i, y + j])
return p
while True:
try:
x, y, size = map(int, input().split(','))
except:
break
if size == 1:
bp = small(x, y)
elif size == 2:
bp = middle(x, y)
elif size == 3:
bp = big(x, y)
for p in bp:
if 0 <= p[0] < 10 and 0 <= p[1] < 10:
paper[p[1]][p[0]] += 1
print(sum(paper[y][x] == 0 for y in range(10) for x in range(10)))
print(max(paper[y][x] for y in range(10) for x in range(10))) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s672221837 | p00026 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
def printp():
for q in p:
print q
def if_in_paper(x,y):
if 0 <= x and x < 10 and 0 <= y and y <10:
return True
else:
return False
def pro(x,y,lis):
for e in lis:
px,py = x+e[0], y+e[1]
if if_in_paper(px,py):
p[py][px] += 1
p = [ [0]*10 for i in range(10)]
small = [[0,0],[1,0],[0,1],[-1,0],[0,-1]]
midium = small + [[1,1],[1,-1],[-1,1],[-1,-1]]
large = midium + [[2,0],[0,2],[-2,0],[0,-2]]
water_list = [small,midium,large]
for s in sys.stdin:
d = map(int,s.split(","))
pro( d[0], d[1], water_list[ d[2]-1 ] )
print sum( [ 1 for i in range(10) for j in range(10) if p[i][j] == 0] )
print max( [ max(q) for q in p] ) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s924942480 | p00026 | Accepted | import sys
f = sys.stdin
def drop(paper, x, y):
if 0 <= x < len(paper[0]) and 0 <= y < len(paper):
paper[y][x] += 1
drop_range = {}
drop_range[1] = ((0, 0), (0, -1), (1, 0), (0, 1), (-1, 0))
drop_range[2] = drop_range[1] + ((-1, -1), (1, -1), (1, 1), (-1, 1))
drop_range[3] = drop_range[2] + ((0, -2), (2, 0), (0, 2), (-2, 0))
paper = [[0 for j in range(10)] for i in range(10)]
for line in f:
x, y, size = map(int, line.split(','))
for dx, dy in drop_range[size]:
drop(paper, x + dx, y + dy)
paper = [x for y in paper for x in y]
print(sum(1 for thick in paper if thick == 0))
print(max(paper)) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s297229653 | p00026 | Accepted | p = [[0 for a in range(10)] for b in range(10)]
def smallink(x,y):
return [(x+i,y+j) for i in range(-1,2,1) for j in range(-1,2,1)\
if abs(i)+abs(j)<=1 and x+i>=0 and x+i<=9 and y+j>=0\
and y+j<=9]
def ink(x,y):
return [(x+i,y+j) for i in range(-1,2,1) for j in range(-1,2,1)\
if x+i>=0 and y+j>=0 and x+i<=9 and y+j<=9]
def bigink(x,y):
return [(x+i,y+j) for i in range(-2,3,1) for j in range(-2,3,1)\
if abs(i)+abs(j)<=2 and x+i>=0 and y+j>=0 and x+i<=9\
and y+j<=9]
while True:
try:
x,y,size=map(int,raw_input().split(","))
if size==1:
L=smallink(x,y)
elif size==2:
L=ink(x,y)
else:
L=bigink(x,y)
while len(L)!=0:
point=L.pop(0)
p[point[0]][point[1]]+=1
except:
break
count=0
max=0
for i in range(10):
for j in range(10):
if(p[i][j]>max):
max=p[i][j]
if(p[i][j]==0):
count+=1
print count
print max | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s190761039 | p00026 | Accepted | import sys
p = [[0 for a in range(10)] for b in range(10)]
def smallink(x,y):
return [(x+i,y+j) for i in range(-1,2,1) for j in range(-1,2,1)\
if abs(i)+abs(j)<=1 and x+i>=0 and x+i<=9 and y+j>=0\
and y+j<=9]
def ink(x,y):
return [(x+i,y+j) for i in range(-1,2,1) for j in range(-1,2,1)\
if x+i>=0 and y+j>=0 and x+i<=9 and y+j<=9]
def bigink(x,y):
return [(x+i,y+j) for i in range(-2,3,1) for j in range(-2,3,1)\
if abs(i)+abs(j)<=2 and x+i>=0 and y+j>=0 and x+i<=9\
and y+j<=9]
for dataset in sys.stdin:
x,y,size=map(int,dataset.split(","))
if size==1:
L=smallink(x,y)
elif size==2:
L=ink(x,y)
else:
L=bigink(x,y)
while len(L)!=0:
point=L.pop(0)
p[point[0]][point[1]]+=1
count=0
max=0
for i in range(10):
for j in range(10):
if(p[i][j]>max):
max=p[i][j]
if(p[i][j]==0):
count+=1
print count
print max | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s443256934 | p00026 | Accepted | board = [[0]*10 for _ in range(10)]
while True:
try:
x, y, size = map(int, input().split(','))
except:
break
small = [(-1, 0), (0, -1), (0, 0), (0, 1), (1, 0)]
med = [(-1, -1), (-1, 0), (-1, 1),
(0, -1), (0, 0), (0, 1),
(1, -1), (1, 0), (1, 1)]
large = [(-2, 0),
(-1, -1), (-1, 0), (-1, 1),
(0, -2), (0, -1), (0, 0), (0, 1), (0, 2),
(1, -1), (1, 0), (1, 1),
(2, 0)]
dyx = [small, med, large][size-1]
for dy, dx in dyx:
ny, nx = y + dy, x + dx
if 0 <= nx < 10 and 0 <= ny < 10:
board[ny][nx] += 1
print(sum(sum(1 for i in range(10) if row[i] == 0) for row in board))
print(max([max(row) for row in board])) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s606079015 | p00026 | Accepted | def main():
if size == 1:
index_lis = [(0,0),(0,-1),(0,1),(-1,0),(1,0)]
elif size == 2:
index_lis = [(0,0),(0,-1),(0,1),(-1,-1),(-1,0),(-1,1),(1,-1),(1,0),(1,1)]
elif size == 3:
index_lis = [(0,0),(0,-1),(0,-2),(0,1),(0,2),(-1,-1),(-1,0),(-1,1),
(1,-1),(1,0),(1,1),(-2,0),(2,0)]
drop(index_lis, x, y)
def drop(index_lis, x, y):
for add_x, add_y in index_lis:
_x = x + add_x
_y = y + add_y
if 0 <= _x <= 9 and 0 <= _y <= 9:
sheet[_x][_y] = sheet[_x][_y] + 1
def check():
total = 0
max_num = 0
for x in range(10):
for y in range(10):
if sheet[x][y] == 0:
total += 1
else:
if sheet[x][y] > max_num:
max_num = sheet[x][y]
print total
print max_num
sheet = []
for i in range(10):
lis = []
for i in range(10):
lis.append(0)
sheet.append(lis)
while True:
try:
x, y, size = map(int, raw_input().split(','))
main()
except EOFError:
check()
break | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s279001464 | p00026 | Accepted | import sys
def small(paper, x, y):
paper[x][y] += 1
paper[x-1][y] += 1
paper[x][y-1] += 1
paper[x][y+1] += 1
paper[x+1][y] += 1
def medium(paper, x, y):
small(paper, x, y)
paper[x-1][y-1] += 1
paper[x-1][y+1] += 1
paper[x+1][y-1] += 1
paper[x+1][y+1] += 1
def large(paper, x, y):
medium(paper, x, y)
paper[x-2][y] += 1
paper[x][y-2] += 1
paper[x][y+2] += 1
paper[x+2][y] += 1
def drop(paper, x, y, size):
if size == 1:
small(paper, x, y)
elif size == 2:
medium(paper, x, y)
else:
large(paper, x, y)
return paper
paper = [[0 for i in range(14)] for j in range(14)]
for s in sys.stdin:
x, y, size = map(int, s.split(','))
paper = drop(paper, x+2, y+2, size)
empty = 0
deep = 0
for i in range(10):
for j in range(10):
if paper[i+2][j+2] == 0:
empty += 1
elif paper[i+2][j+2] > deep:
deep = paper[i+2][j+2]
print(empty)
print(deep) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s672683221 | p00026 | Accepted | # -*- coding:utf-8 -*-
def check(x,i,y,j):
flagx=True if (x+i>=0 and x+i<=9) else False
flagy=True if (y+j>=0 and y+j<=9) else False
return (flagx and flagy)
def main():
LIST=[]
for i in range(10):
LIST.append([0,0,0,0,0,0,0,0,0,0])
count=0
M=0
while True:
try:
x,y,size=map(int,input().split(","))
if size==1:
for i in range(-1,2):
for j in range(-1,2):
if check(x,i,y,j) and abs(i)+abs(j)<=1:
LIST[y+j][x+i]+=1
elif size==2:
for i in range(-1,2):
for j in range(-1,2):
if check(x,i,y,j) and abs(i)+abs(j)<=2:
LIST[y+j][x+i]+=1
elif size==3:
for i in range(-2,3):
for j in range(-2,3):
if check(x,i,y,j) and abs(i)+abs(j)<=2:
LIST[y+j][x+i]+=1
except:
break
for item in LIST:
tmp=max(x for x in item)
M=max(tmp,M)
for item in LIST:
count+=item.count(0)
print(count)
print(M)
if __name__ == '__main__':
main() | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s561197308 | p00026 | Accepted | #!/usr/bin/env python
# -*- coding: UTF-8 -*-
l=[[0]*10 for _ in range(10)]
while 1:
try:
x,y,s=map(int,raw_input().split(','))
l[y][x]+=1
syo=[[0,1],[0,-1],[1,0],[-1,0]]
chu=[[1,1],[-1,-1],[1,-1],[-1,1]]
dai=[[0,2],[0,-2],[2,0],[-2,0]]
for i in syo:
if 0<=y+i[0]<=9 and 0<=x+i[1]<=9:
l[y+i[0]][x+i[1]]+=1
if s>1:
for i in chu:
if 0<=y+i[0]<=9 and 0<=x+i[1]<=9:
l[y+i[0]][x+i[1]]+=1
if s>2:
for i in dai:
if 0<=y+i[0]<=9 and 0<=x+i[1]<=9:
l[y+i[0]][x+i[1]]+=1
except:
break
a=b=0
for i in l:
a+=i.count(0)
b=max(b,max(i))
print a
print b | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s474101655 | p00026 | Accepted | p = [[0 for i in range(14)] for j in range(14)]
c, m = 0, 0
while True:
try:
x, y, size = map(int,input().split(','))
except:
break
x += 2
y += 2
p[x][y] += 1
p[x - 1][y] += 1
p[x + 1][y] += 1
p[x][y - 1] += 1
p[x][y + 1] += 1
if size > 1:
p[x - 1][y - 1] += 1
p[x - 1][y + 1] += 1
p[x + 1][y - 1] += 1
p[x + 1][y + 1] += 1
if size > 2:
p[x - 2][y] += 1
p[x + 2][y] += 1
p[x][y - 2] += 1
p[x][y + 2] += 1
for i in range(2, 12):
for j in range(2, 12):
if p[i][j] == 0:
c += 1
elif p[i][j] > m:
m = p[i][j]
print(c)
print(m) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s013995884 | p00026 | Accepted | from __future__ import (absolute_import, division, print_function,
unicode_literals)
from sys import stdin
from collections import Counter
import sys
NUM = [[0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0],
[0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
paper = Counter()
for line in sys.stdin:
x, y, size = (int(s) for s in line.split(','))
xidx = [x, x-1, x, x+1, x-2, x-1, x, x+1, x+2, x-1, x, x+1, x]
yidx = [y-2, y-1, y-1, y-1, y, y, y, y, y, y+1, y+1, y+1, y+2]
val = NUM[size-1]
for a, b, i in zip(xidx, yidx, xrange(len(xidx))):
if a < 0 or 9 < a or b < 0 or 9 < b:
continue
paper[a + b * 10] += val[i]
print(sum(1 for i in xrange(100) if not paper[i]))
print(max(paper[i] for i in xrange(100))) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s601722064 | p00026 | Accepted | # -*- coding: utf-8 -*-
import sys
def small_inc(x, y, cells):
cells[x][y] += 1
if y > 0:
cells[x][y-1] += 1
if x > 0:
cells[x-1][y] += 1
if x < MAPSIZE-1:
cells[x+1][y] += 1
if y < MAPSIZE-1:
cells[x][y+1] += 1
def medium_inc(x, y, cells):
if y > 0:
cells[x][y-1] += 1
if x > 0:
cells[x-1][y-1] += 1
if x < MAPSIZE-1:
cells[x+1][y-1] += 1
cells[x][y] += 1
if x > 0:
cells[x-1][y] += 1
if x < MAPSIZE-1:
cells[x+1][y] += 1
if y < MAPSIZE-1:
cells[x][y+1] += 1
if x > 0:
cells[x-1][y+1] += 1
if x < MAPSIZE-1:
cells[x+1][y+1] += 1
def large_inc(x, y, cells):
if y > 1:
cells[x][y-2] += 1
if y > 0:
cells[x][y-1] += 1
if x > 0:
cells[x-1][y-1] += 1
if x < MAPSIZE-1:
cells[x+1][y-1] += 1
cells[x][y] += 1
if x > 1:
cells[x-2][y] += 1
if x > 0:
cells[x-1][y] += 1
if x < MAPSIZE-1:
cells[x+1][y] += 1
if x < MAPSIZE-2:
cells[x+2][y] += 1
if y < MAPSIZE-1:
cells[x][y+1] += 1
if x > 0:
cells[x-1][y+1] += 1
if x < MAPSIZE-1:
cells[x+1][y+1] += 1
if y < MAPSIZE-2:
cells[x][y+2] += 1
SMALL = 1
MEDIUM = 2
LARGE = 3
MAPSIZE = 10
cells = [[0 for i in range(MAPSIZE)] for j in range(MAPSIZE)]
for line in sys.stdin:
x , y, size = map(int, line.split(','))
if size == SMALL:
small_inc(x, y, cells)
elif size == MEDIUM:
medium_inc(x, y, cells)
elif size == LARGE:
large_inc(x, y, cells)
count = max_d = 0
for i in range(MAPSIZE):
for j in range(MAPSIZE):
if cells[i][j] == 0:
count += 1
else:
max_d = max(max_d, cells[i][j])
print count
print max_d | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s246112465 | p00026 | Accepted | class Paper:
def __init__(self, x, y):
self.A = [[0 for i in range(x)] for j in range(y)]
self.size = (x, y)
def drop(self, x, y, s):
if s == 1:
if y+1 <= self.size[1]-1:
self.A[y+1][x] += 1
for i in range(max(0, x-1) , 1 + min(self.size[0]-1, x+1)):
self.A[y][i] += 1
if y-1 >= 0:
self.A[y-1][x] += 1
if s == 2:
if y+1 <= self.size[1]-1:
for i in range(max(0, x-1) , 1 + min(self.size[0]-1, x+1)):
self.A[y+1][i] += 1
for i in range(max(0, x-1) , 1 + min(self.size[0]-1, x+1)):
self.A[y][i] += 1
if y-1 >= 0:
for i in range(max(0, x-1) , 1 + min(self.size[0]-1, x+1)):
self.A[y-1][i] += 1
if s == 3:
if y+2 <= self.size[1]-1:
self.A[y+2][x] += 1
if y+1 <= self.size[1]-1:
for i in range(max(0, x-1) , 1 + min(self.size[0]-1, x+1)):
self.A[y+1][i] += 1
for i in range(max(0, x-2) , 1 + min(self.size[0]-1, x+2)):
self.A[y][i] += 1
if y-1 >= 0:
for i in range(max(0, x-1) , 1 + min(self.size[0]-1, x+1)):
self.A[y-1][i] += 1
if y-2 >= 0:
self.A[y-2][x] += 1
if __name__ == "__main__":
import sys
p = Paper(10, 10)
L = sys.stdin.readlines()
for l in L:
x, y, s = map(int, l.split(','))
p.drop(x, y, s)
# for i in range(10):
# print(p.A[i])
# print()
temp = []
for y in p.A:
temp.extend(y)
A1 = temp.count(0)
A2 = max(temp)
print(A1)
print(A2)
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s148461864 | p00026 | Accepted | paper=[[-float('inf')]*14]*2+[[-float('inf')]*2+[0]*10+[-float('inf')]*2 for _ in xrange(10)]+[[-float('inf')]*14]*2
while 1:
try:
x,y,size=map(int,raw_input().split(","))
x+=2
y+=2
paper[x][y]+=1
paper[x+1][y]+=1
paper[x-1][y]+=1
paper[x][y+1]+=1
paper[x][y-1]+=1
if size>=2:
paper[x+1][y+1]+=1
paper[x+1][y-1]+=1
paper[x-1][y+1]+=1
paper[x-1][y-1]+=1
if size==3:
paper[x+2][y]+=1
paper[x-2][y]+=1
paper[x][y+2]+=1
paper[x][y-2]+=1
except:
break
ct0=0
maxpaper=0
for i in xrange(14):
for j in xrange(14):
if paper[i][j]==0:
ct0+=1
if maxpaper<paper[i][j]:
maxpaper=paper[i][j]
print(ct0)
print(maxpaper) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s594056350 | p00026 | Accepted | d = [[0] * 10 for i in range(10)]
def b(x, y):
for i in range(x - 2, x + 3):
a = 3 - abs(x - i)
for a in range(y - a + 1, y + a):
if 0 <= i < 10 and 0 <= a < 10:
d[a][i] += 1
def m(x, y):
for i in range(x - 1, x + 2):
for j in range(y - 1, y + 2):
if 0 <= i < 10 and 0 <= j < 10:
d[j][i] += 1
def s(x, y):
r = (1, 0)
for i in range(x - 1, x + 2):
a = abs(x - i)
for j in range(y - r[a], y + r[a] + 1):
if 0 <= i < 10 and 0 <= j < 10:
d[j][i] += 1
while 1:
try:
f = (None, s, m, b)
x, y, size = list(map(int, input().split(',')))
f[size](x, y)
except:
break
r1 = r2 = 0
for i in range(10):
for j in range(10):
r1 += 1 if d[i][j] == 0 else 0
r2 = max(r2, d[i][j])
print(r1)
print(r2) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s007285829 | p00026 | Accepted | masu = [[0 for x in range(10)] for y in range(10)]
syou = [[-1,0], [0,-1], [0,0], [0,1], [1,0]]
tyuu = [[-1,-1], [-1,1], [1,-1], [1,1]] + syou
dai = [[-2,0], [0,-2], [0,2], [2,0]] + tyuu
def drop(x,y,s):
if s == 1: l = syou
elif s == 2: l = tyuu
elif s == 3: l = dai
for dx,dy in l:
nx = x + dx
ny = y + dy
if nx in range(10) and ny in range(10):
masu[ny][nx] += 1
while True:
try:
x,y,s = map(int, input().split(','))
drop(x,y,s)
except EOFError:
break
max = cnt = 0
for y in range(10):
for x in range(10):
if masu[y][x] == 0: cnt += 1
if max < masu[y][x]: max = masu[y][x]
print(cnt)
print(max) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s115588064 | p00026 | Accepted | a = [[0] * 14 for _ in range(14)]
while True:
try:
x, y, s = map(int, input().split(','))
except:
break
x += 2
y += 2
for d in [(0, 0), (0, -1), (0, 1), (-1, 0), (1, 0)]:
a[x + d[0]][y + d[1]] += 1
if s >= 2:
for d in [(1, 1), (1, -1), (-1, 1), (-1, -1)]:
a[x + d[0]][y + d[1]] += 1
if s == 3:
for d in [(0, 2), (0, -2), (2, 0), (-2, 0)]:
a[x + d[0]][y + d[1]] += 1
print(sum(a[i][2:12].count(0) for i in range(2, 12)))
print(max(max(a[i][2:12]) for i in range(2, 12))) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s466973868 | p00026 | Accepted | p = [[0 for i in xrange(10)] for i in xrange(10)]
def drop(x, y, s):
r = []
d = [[x, y - 1], [x - 1, y], [x + 1, y], [x, y + 1], \
[x - 1, y + 1], [x + 1, y + 1], [x - 1, y - 1], [x + 1, y - 1], \
[x, y + 2], [x - 2, y], [x + 2, y], [x, y - 2]]
for i in d[0:s*4]:
if min(i) >= 0 and max(i) < 10: r.append(i)
p[x][y] += 1
for i in r:
p[i[0]][i[1]] += 1
while 1:
try:
x, y, s = map(int, raw_input().split(','))
drop(x, y, s)
except:
break
print sum([i.count(0) for i in p])
print max([max(i) for i in p]) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s262538893 | p00026 | Accepted | p = [[0 for i in xrange(10)] for i in xrange(10)]
def drop(x, y, s):
d = [[x, y - 1], [x - 1, y], [x + 1, y], [x, y + 1], \
[x - 1, y + 1], [x + 1, y + 1], [x - 1, y - 1], [x + 1, y - 1], \
[x, y + 2], [x - 2, y], [x + 2, y], [x, y - 2]]
for i in d[0:s*4]:
if min(i) >= 0 and max(i) < 10: p[i[0]][i[1]] += 1
p[x][y] += 1
while 1:
try:
x, y, s = map(int, raw_input().split(','))
drop(x, y, s)
except:
break
print sum([i.count(0) for i in p])
print max([max(i) for i in p]) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s844727555 | p00026 | Accepted | import sys
drops = [None,
[(0,0),(-1,0),(1,0),(0,-1),(0,1)],
[(0,0),(-1,0),(1,0),(0,-1),(0,1),(-1,1),(-1,-1),(1,-1),(1,1)],
[(0,0),(-1,0),(1,0),(0,-1),(0,1),(-1,1),(-1,-1),(1,-1),(1,1),(-2,0),(2,0),(0,-2),(0,2)]]
B = [[0 for j in xrange(10)] for i in xrange(10)]
for line in sys.stdin:
x, y, s = map(int, line.rstrip().split(','))
for dx, dy in drops[s]:
nx, ny = x+dx, y+dy
if (0 <= nx <= 9 and 0 <= ny <= 9):
B[ny][nx] += 1
emp, m = 0, 0
for i in xrange(10):
for j in xrange(10):
if B[i][j] == 0:
emp += 1
m = max(m, B[i][j])
print emp
print m | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s746401303 | p00026 | Accepted | import sys
field = [[0 for i in range(10)] for j in range(10)]
def ink(x, y, s):
for dx, dy in ((0, 0), (0, 1), (1, 0), (-1, 0), (0, -1)):
plot(x + dx, y + dy)
if s == 1:
return
for dx, dy in ((1, 1), (-1, -1), (-1, 1), (1, -1)):
plot(x + dx, y + dy)
if s == 2:
return
for dx, dy in ((2, 0), (0, 2), (-2, 0), (0, -2)):
plot(x + dx, y + dy)
def plot(x, y):
if 0 <= x < 10 and 0 <= y < 10:
field[x][y] += 1
for line in sys.stdin:
x, y, s = map(int, line.split(','))
ink(x, y, s)
print(sum(field, []).count(0))
print(max(sum(field, []))) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s459683545 | p00026 | Accepted | Masu = []
def access(x,y):
if x < 0 or y < 0 or x > 9 or y > 9:
return
Masu[y][x] += 1
for i in range(10):
Masu.append([0,0,0,0,0,0,0,0,0,0])
kosu = 0
komax = 0
while True:
try:
x,y,s = map(int,input().split(","))
if s == 1:
for j in range(3):
access(y +1 - j,x)
access(y,x - 1)
access(y,x + 1)
elif s == 2:
for k in range(3):
for l in range(3):
access(y + 1 - k,x + 1 -l)
elif s == 3:
for k in range(3):
for l in range(3):
access(y + 1 - k,x + 1 -l)
access(y - 2,x)
access(y + 2,x)
access(y,x + 2)
access(y,x - 2)
except (EOFError,ValueError):
for i in range(10):
kosu += Masu[i].count(0)
for j in range(10):
if komax < max(Masu[j]):
komax = max(Masu[j])
print(kosu)
print(komax)
break | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s011332230 | p00026 | Accepted | import sys
class Paper(object):
def __init__(self, x=None, y=None):
if x == None:
self.x = 10
else:
self.x = x
if y == None:
self.y = 10
else:
self.y = y
t = [0] * self.x
self.sheet = [t[:] for _ in range(self.y)]
def drop_ink(self, ink):
x, y, s = ink
if s == 1:
self.process_ink(x, y)
self.process_ink(x+1, y)
self.process_ink(x-1, y)
self.process_ink(x, y+1)
self.process_ink(x, y-1)
elif s == 2:
self.process_ink(x-1, y-1)
self.process_ink(x, y-1)
self.process_ink(x+1, y-1)
self.process_ink(x-1, y)
self.process_ink(x, y)
self.process_ink(x+1, y)
self.process_ink(x-1, y+1)
self.process_ink(x, y+1)
self.process_ink(x+1, y+1)
elif s == 3:
self.process_ink(x, y-2)
self.process_ink(x-1, y-1)
self.process_ink(x, y-1)
self.process_ink(x+1, y-1)
self.process_ink(x-2, y)
self.process_ink(x-1, y)
self.process_ink(x, y)
self.process_ink(x+1, y)
self.process_ink(x+2, y)
self.process_ink(x-1, y+1)
self.process_ink(x, y+1)
self.process_ink(x+1, y+1)
self.process_ink(x, y+2)
def process_ink(self, x, y):
if 0 <= x < self.x and 0 <= y < self.y:
self.sheet[y][x] += 1
def print_sheet(self):
for row in self.sheet:
print(row)
if __name__ == '__main__':
ink_drops = []
for line in sys.stdin:
ink_drops.append([int(x) for x in line.strip().split(',')])
# for line in sys.stdin:
# try:
# ink_drops.append([int(x) for x in line.strip().split(',')])
# except ValueError:
# break
p = Paper(10, 10)
for ink in ink_drops:
p.drop_ink(ink)
#p.print_sheet()
#print('=' * 64)
white_cell = 0
max_ink = 0
for r in p.sheet:
white_cell += r.count(0)
max_ink = max(max(r), max_ink)
print(white_cell)
print(max_ink) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s634855216 | p00026 | Accepted |
board=[[0]*10 for i in range(10)]
ink=[[[0,0,0,0,0],[0,0,1,0,0],[0,1,1,1,0],[0,0,1,0,0],[0,0,0,0,0]],
[[0,0,0,0,0],[0,1,1,1,0],[0,1,1,1,0],[0,1,1,1,0],[0,0,0,0,0]],
[[0,0,1,0,0],[0,1,1,1,0],[1,1,1,1,1],[0,1,1,1,0],[0,0,1,0,0]]]
while True:
try:
x,y,s=map(int,input().split(","))
except:
break
for i in range(5):
for j in range(5):
if 0<=i+y-2<=9 and 0<=j+x-2<=9:
board[i+y-2][j+x-2]+=ink[s-1][i][j]
flat=sum(board,[])
print(flat.count(0))
print(max(flat)) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s470087391 | p00026 | Accepted | a = [[0 for i2 in range(10)] for i1 in range(10)]
def small_ink(x,y):
a[x][y] += 1
a[x-1][y] += 1
try:
a[x+1][y] += 1
except:
pass
a[x][y-1] += 1
try:
a[x][y+1] += 1
except:
pass
if x-1 < 0:
a[x-1][y] -= 1
if y-1 < 0:
a[x][y-1] -= 1
return 0
def mid_ink(x,y):
for i in [-1,0,1]:
for j in [-1,0,1]:
if 9 >= x+i >= 0 and 9>= y+j >= 0:
a[x+i][y+j] += 1
return 0
def big_ink(x,y):
mid_ink(x,y)
a[x-2][y] += 1
try:
a[x+2][y] += 1
except:
pass
a[x][y-2] += 1
try:
a[x][y+2] += 1
except:
pass
if x-2 < 0:
a[x-2][y] -= 1
if y-2 < 0:
a[x][y-2] -= 1
return 0
def ink(x,y,s):
if s == 1:
small_ink(x,y)
if s == 2:
mid_ink(x,y)
if s == 3:
big_ink(x,y)
return 0
while True:
try:
x,y,s = map(int,input().split(','))
ink(x,y,s)
except EOFError:
break
nu = 0
for i in range(10):
for j in range(10):
if a[i][j] == 0:
nu += 1
print(nu)
max_val = 0
for i in range(10):
for j in range(10):
if a[i][j] > max_val:
max_val = a[i][j]
print(max_val) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s426531926 | p00026 | Accepted | paper = [[0] * 10 for i in range(10)]
while True:
try:
x,y,s = map(int,input().split(','))
except:
break
if s == 1:
for i in range(10):
for j in range(10):
if abs(x - i) + abs(y - j) <= 1:
paper [i] [j] += 1
elif s == 2:
for i in range(10):
for j in range(10):
if abs(x - i) <= 1 and abs(y - j) <= 1:
paper [i] [j] += 1
else:
for i in range(10):
for j in range(10):
if abs(x - i) + abs(y - j) <= 2:
paper [i] [j] += 1
ls = sum(paper,[])
print(ls.count(0))
print(max(ls)) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s583795074 | p00026 | Accepted | pap = [[0 for x in range(10)] for y in range(10)]
def brot(x,y,s):
if s==1:
for dx in range(-1,+1+1):
for dy in range(-1,+1+1):
px = x + dx
py = y + dy
if abs(dx)+abs(dy)<2 and px in range(0,10) and py in range(0,10):
pap[py][px] += 1
elif s==2:
for dx in range(-1,+1+1):
for dy in range(-1,+1+1):
px = x + dx
py = y + dy
if px in range(0,10) and py in range(0,10):
pap[py][px] += 1
elif s==3:
for dx in range(-2,+2+1):
for dy in range(-2,+2+1):
px = x + dx
py = y + dy
if abs(dx)+abs(dy)<3 and px in range(0,10) and py in range(0,10):
pap[py][px] += 1
else:
raise(ValueError)
def ans():
bmax = 0
wcount = 0
for y in range(0,+9+1):
for x in range(0,+9+1):
b = pap[y][x]
if b > bmax:
bmax = b
elif b == 0:
wcount += 1
return(wcount,bmax)
while True:
try:
x,y,s = list(map(int, input().split(',')))
brot(x,y,s)
except EOFError:
break
print("%d\n%d" % ans()) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s468067734 | p00026 | Accepted | pap = [[0 for x in range(10)] for y in range(10)]
ink = [ [],
[[-1,0],[0,-1],[0,0],[0,1],[1,0]],
[[-1,-1],[-1,0],[-1,1],[0,-1],[0,0],[0,1],[1,-1],[1,0],[1,1]],
[[-2,0],[-1,-1],[-1,0],[-1,1],[0,-2],[0,-1],[0,0],[0,1],[0,2],[1,-1],[1,0],[1,1],[2,0]] ]
def brot(x,y,s):
global pap
for i in ink[s]:
px = x + i[0]
py = y + i[1]
if px in range(0,10) and py in range(0,10):
pap[py][px] += 1
def ans():
bmax = max(pap[y][x] for y in range(10) for x in range(10))
wcount = sum(pap[y][x] == 0 for y in range(10) for x in range(10))
return(wcount,bmax)
if __name__ == "__main__":
while True:
try:
x,y,s = list(map(int, input().split(',')))
brot(x,y,s)
except EOFError:
break
print("%d\n%d" % ans()) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s623677683 | p00026 | Accepted | arr = [0]*100
while True:
try:
x,y,s = map(int, input().split(","))
if s==3:
if x <= 7:
arr[10*y+x+2] += 1
if x >= 2:
arr[10*y+x-2] += 1
if y <= 7:
arr[10*y+x+20] += 1
if y >= 2:
arr[10*y+x-20] += 1
if s>=2:
if x != 9 and y != 9:
arr[10*y+x+11] += 1
if x != 9 and y != 0:
arr[10*y+x-9] += 1
if x != 0 and y != 0:
arr[10*y+x-11] += 1
if x != 0 and y != 9:
arr[10*y+x+9] += 1
if True:
if x != 9:
arr[10*y+x+1] += 1
if x != 0:
arr[10*y+x-1] += 1
if y != 9:
arr[10*y+x+10] += 1
if y != 0:
arr[10*y+x-10] += 1
if True:
if True:
arr[10*y+x] += 1
except EOFError:
break
print(arr.count(0))
print(max(arr)) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s067750001 | p00026 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
import math
P = [[0 for i in range(10)] for j in range(10)]
def paint(x, y):
if 0 <= x <= 9 and 0 <= y <= 9:
P[x][y] += 1
for s in sys.stdin:
x, y, s = map(int, s.split(','))
if s >= 1:
paint(x, y)
paint(x - 1, y)
paint(x + 1, y)
paint(x, y - 1)
paint(x, y + 1)
if s >= 2:
paint(x - 1, y - 1)
paint(x + 1, y - 1)
paint(x - 1, y + 1)
paint(x + 1, y + 1)
if s >= 3:
paint(x - 2, y)
paint(x + 2, y)
paint(x, y - 2)
paint(x, y + 2)
# debug
#print('-----------------------')
#for row in P:
# print(*row)
white = 0
for row in P:
white += row.count(0)
max_value = 0
for row in P:
max_value = max(max_value, max(row))
print(white)
print(max_value) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s930056758 | p00026 | Accepted | import sys
n1 = [[0, 1], [1, 0], [-1, 0], [0, -1]]
n2 = n1 + [[a, b] for a in [-1, 1] for b in [-1, 1]]
n3 = n2 + [[a*2, b*2] for a, b in n1]
mas = [[0]*10 for i in range(10)]
for i in sys.stdin:
try:
x, y, a = list(map(int, i.split(",")))
mas[y][x] += 1
for k,l in eval("n"+str(a)):
try:
if y+l >= 0 and x+k >= 0:
mas[y+l][x+k] += 1
except IndexError:
continue
except ValueError:
break
print(len([i for x in mas for i in x if not i]))
print(max([max(v) for v in mas])) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s152224981 | p00026 | Accepted | t = [[0 for i in range(10)] for j in range(10)]
case1 = [(0, 0), (0, -1), (1, 0), (0, 1), (-1, 0)]
case2 = [(1, -1), (1, 1), (-1, 1), (-1, -1)]
case3 = [(0, -2), (2, 0), (0, 2), (-2, 0)]
while True:
try:
x, y, s = map(int, input().split(','))
except:
break
for c in [case1, case2, case3][:s]:
for _x, _y in c:
if y+_y < 0 or x+_x < 0:
continue
try:
t[y+_y][x+_x] += 1
except IndexError:
continue
print(sum(1 for l in t for v in l if not v))
print(max(v for l in t for v in l)) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s762407621 | p00026 | Accepted | paper = [[0 for _ in range(10)] for _ in range(10)]
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
def paint(x, y):
if 0 <= x <= 9 and 0 <= y <= 9:
paper[x][y] += 1
while True:
try:
x, y, s = map(int, input().split(","))
except EOFError:
break
if x == y == s == -1:
break
paint(x, y)
for i in range(4):
paint(x + dx[i], y + dy[i])
if s >= 2:
for i in range(4):
paint(x + dx[i] + dx[(i + 1) % 4], y + dy[i] + dy[(i + 1) % 4])
if s >= 3:
for i in range(4):
paint(x + 2 * dx[i], y + 2 * dy[i])
print(sum(paper[i].count(0) for i in range(10)))
print(max(paper[i][j] for i in range(10) for j in range(10))) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s529028638 | p00026 | Accepted | import sys
table = [[0 for j in range(10)] for i in range(10)]
def flag(x, y):
if x > 9 or y > 9 or x < 0 or y < 0:
return False
else:
return True
def small(x, y):
table[x][y] += 1
if flag(x+1, y):
table[x+1][y] += 1
if flag(x-1, y):
table[x-1][y] += 1
if flag(x, y+1):
table[x][y+1] += 1
if flag(x, y-1):
table[x][y-1] += 1
def medium(x, y):
small(x, y)
if flag(x+1, y+1):
table[x+1][y+1] += 1
if flag(x+1, y-1):
table[x+1][y-1] += 1
if flag(x-1, y+1):
table[x-1][y+1] += 1
if flag(x-1, y-1):
table[x-1][y-1] += 1
def large(x, y):
medium(x, y)
if flag(x+2, y):
table[x+2][y] += 1
if flag(x-2, y):
table[x-2][y] += 1
if flag(x, y+2):
table[x][y+2] += 1
if flag(x, y-2):
table[x][y-2] += 1
def ink(x, y, s):
if s == 1:
small(x, y)
if s == 2:
medium(x, y)
if s == 3:
large(x, y)
def Search():
counter = 0
thickest = 0
for i in range(10):
for j in range(10):
if table[i][j] == 0:
counter += 1
elif thickest < table[i][j]:
thickest = table[i][j]
print(counter)
print(thickest)
for l in sys.stdin:
data = list(map(int, l.split(",")))
x, y, s = data
ink(x, y, s)
Search() | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s663494400 | p00026 | Accepted | # Aizu Problem 0026: Dropping Ink
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
paper = [[0 for col in range(10)] for row in range(10)]
# ink forms: 1=small, 2=medium, 3=large
ink_forms = {1: [[0, 0], [-1, 0], [1, 0], [0, -1], [0, 1]],
2: [[-1, -1], [-1, 0], [-1, 1],
[0, 1], [0, 0], [0, -1],
[1, -1], [1, 0], [1, 1]],
3: [[-1, -1], [-1, 0], [-1, 1],
[0, 1], [0, 0], [0, -1],
[1, -1], [1, 0], [1, 1],
[-2, 0], [2, 0], [0, -2], [0, 2]]}
while True:
try:
x, y, s = [int(_) for _ in input().split(',')]
except EOFError:
break
for x_off, y_off in ink_forms[s]:
x1 = x + x_off
y1 = y + y_off
if 0 <= x1 < 10 and 0 <= y1 < 10:
paper[x1][y1] += 1
print(sum([row.count(0) for row in paper]))
print(max([max(row) for row in paper])) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s631478181 | p00026 | Accepted | import sys
b = [ list(0 for i in range(14)) for j in range(14)]
def s(b,x,y):
b[x][y] += 1
b[x+1][y] += 1
b[x-1][y] += 1
b[x][y+1] += 1
b[x][y-1] += 1
def m(b,x,y):
b[x-1][y-1] += 1
b[x ][y-1] += 1
b[x+1][y-1] += 1
b[x-1][y ] += 1
b[x ][y ] += 1
b[x+1][y ] += 1
b[x-1][y+1] += 1
b[x ][y+1] += 1
b[x+1][y+1] += 1
def l(b,x,y):
b[x ][y-2] += 1
b[x-1][y-1] += 1
b[x ][y-1] += 1
b[x+1][y-1] += 1
b[x-2][y ] += 1
b[x-1][y ] += 1
b[x ][y ] += 1
b[x+1][y ] += 1
b[x+2][y ] += 1
b[x-1][y+1] += 1
b[x ][y+1] += 1
b[x+1][y+1] += 1
b[x ][y+2] += 1
for line in sys.stdin:
d = list(map(int,line.split(",")))
c = d[2]
x = d[0] + 2
y = d[1] + 2
if c == 1:
s(b,x,y)
elif c == 2:
m(b,x,y)
elif c == 3:
l(b,x,y)
ttl = 0
num = 0
max = 0
for x in range(2,12):
for y in range(2,12):
ttl += 1
if b[x][y] == 0:
num += 1
if b[x][y] > max:
max = b[x][y]
print(num)
print(max) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s981917439 | p00026 | Accepted | paper = [[0 for i in range(10)] for j in range(10)]
def drop_ink(x, y, s):
for i in range(-1, 2):
for j in range(-1, 2):
if s == 1 and i * j != 0:
continue
if 0 <= x + i < 10 and 0 <= y + j < 10:
paper[x+i][y+j] += 1
if s == 3:
if x - 2 >= 0:
paper[x-2][y] += 1
if x + 2 < 10:
paper[x+2][y] += 1
if y - 2 >= 0:
paper[x][y-2] += 1
if y + 2 < 10:
paper[x][y+2] += 1
while True:
try:
x, y, s = map(int, input().split(','))
drop_ink(x, y, s)
except:
break
count = 0
max_density = 0
for i in range(10):
for j in range(10):
if paper[i][j] == 0:
count += 1
elif paper[i][j] > max_density:
max_density = paper[i][j]
print(count)
print(max_density) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s138880683 | p00026 | Accepted | A=[[int(0) for i in range(10)]for j in range(10)]
count=0
while 1:
try:
x,y,s = map(int, input().split(','))
if s==1:
for i in range(x-1,x+2):
if i>=0 and i<=9:
A[i][y]=A[i][y]+1
for i in range(y-1,y+2):
if i>=0 and i<=9:
A[x][i]=A[x][i]+1
A[x][y]=A[x][y]-1
elif s==2:
for i in range(x-1,x+2):
for j in range(y-1,y+2):
if i>=0 and i<=9 and j>=0 and j<=9:
A[i][j]=A[i][j]+1
else:
for i in range(x-2,x+3):
if i>=0 and i<=9:
A[i][y]=A[i][y]+1
for i in range(y-2,y+3):
if i>=0 and i<=9:
A[x][i]=A[x][i]+1
for i in range(x-1,x+2):
if i>=0 and i<=9:
A[i][y]=A[i][y]-1
for i in range(y-1,y+2):
if i>=0 and i<=9:
A[x][i]=A[x][i]-1
for i in range(x-1,x+2):
for j in range(y-1,y+2):
if i>=0 and i<=9 and j>=0 and j<=9:
A[i][j]=A[i][j]+1
except:
break
num=0
for i in range(10):
for j in range(10):
if A[i][j]==0:
count=count+1
if A[i][j]!=0:
if num<A[i][j]:
num=A[i][j]
print(count)
print(num) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s847098597 | p00026 | Accepted | def check(x, y):
return 0 <= x <= 9 and 0 <= y <= 9
def small(x, y, area):
if check(x+1, y):
area[x+1][y] += 1
if check(x, y+1):
area[x][y+1] += 1
if check(x-1, y):
area[x-1][y] += 1
if check(x, y-1):
area[x][y-1] += 1
area[x][y] += 1
return area
def mediam(x, y, area):
area = small(x, y, area)
if check(x+1, y+1):
area[x+1][y+1] += 1
if check(x+1, y-1):
area[x+1][y-1] += 1
if check(x-1, y+1):
area[x-1][y+1] += 1
if check(x-1, y-1):
area[x-1][y-1] += 1
return area
def large(x, y, area):
area = mediam(x, y, area)
if check(x+2, y):
area[x+2][y] += 1
if check(x, y+2):
area[x][y+2] += 1
if check(x-2, y):
area[x-2][y] += 1
if check(x, y-2):
area[x][y-2] += 1
return area
area = [[0 for i in range(10)] for j in range(10)]
while True:
try:
x, y, s = map(int, input().split(','))
except:
break
if s == 1:
area = small(x, y, area)
if s == 2:
area = mediam(x, y, area)
if s == 3:
area = large(x, y, area)
max = 0
cnt = 0
for i in range(10):
for j in range(10):
if area[i][j] == 0:
cnt += 1
if area[i][j] > max:
max = area[i][j]
print(cnt)
print(max) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s315495998 | p00026 | Accepted | p = [[0 for i in range(14)] for j in range(14)]
while True:
try:
x_inp, y_inp, s = map(int, input().split(","))
x = x_inp + 2
y = y_inp + 2
if s == 1:
p[y-1][x] = p[y-1][x] + 1
p[y][x-1] = p[y][x-1] + 1
p[y][x] = p[y][x] + 1
p[y][x+1] = p[y][x+1] + 1
p[y+1][x] = p[y+1][x] + 1
elif s == 2:
p[y-1][x-1] = p[y-1][x-1] + 1
p[y-1][x] = p[y-1][x] + 1
p[y-1][x+1] = p[y-1][x+1] + 1
p[y][x-1] = p[y][x-1] + 1
p[y][x] = p[y][x] + 1
p[y][x+1] = p[y][x+1] + 1
p[y+1][x-1] = p[y+1][x-1] + 1
p[y+1][x] = p[y+1][x] + 1
p[y+1][x+1] = p[y+1][x+1] + 1
else:
p[y-2][x] += 1
p[y-1][x-1] = p[y-1][x-1] + 1
p[y-1][x] = p[y-1][x] + 1
p[y-1][x+1] = p[y-1][x+1] + 1
p[y][x-2] = p[y][x-2] + 1
p[y][x-1] = p[y][x-1] + 1
p[y][x] = p[y][x] + 1
p[y][x+1] = p[y][x+1] + 1
p[y][x+2] = p[y][x+2] + 1
p[y+1][x-1] = p[y+1][x-1] + 1
p[y+1][x] = p[y+1][x] + 1
p[y+1][x+1] = p[y+1][x+1] + 1
p[y+2][x] += 1
except:
break
p_trim = [p[i][2:12] for i in range(2,12)]
p_flatten = sum(p_trim,[])
print(sum(x==0 for x in p_flatten))
print(max(p_flatten))
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s566744016 | p00026 | Accepted | import sys
def small(grid, x, y):
grid[x][y] += 1
grid[x + 1][y] += 1
grid[x][y + 1] += 1
grid[x][y - 1] += 1
grid[x - 1][y] += 1
return grid
def middle(grid, x, y):
grid[x][y] += 1
grid[x + 1][y] += 1
grid[x][y + 1] += 1
grid[x][y - 1] += 1
grid[x - 1][y] += 1
grid[x - 1][y - 1] += 1
grid[x - 1][y + 1] += 1
grid[x + 1][y + 1] += 1
grid[x + 1][y - 1] += 1
return grid
def large(grid, x, y):
grid[x][y] += 1
grid[x + 1][y] += 1
grid[x][y + 1] += 1
grid[x][y - 1] += 1
grid[x - 1][y] += 1
grid[x - 1][y - 1] += 1
grid[x - 1][y + 1] += 1
grid[x + 1][y + 1] += 1
grid[x + 1][y - 1] += 1
grid[x][y + 2] += 1
grid[x][y - 2] += 1
grid[x + 2][y] += 1
grid[x - 2][y] += 1
return grid
grid = [[0 for _ in range(14)] for __ in range(14)]
for line in sys.stdin:
d = list(map(int, line.split(",")))
x = d[0] + 2
y = d[1] + 2
ink_size = d[2]
if ink_size == 1:
grid = small(grid, x, y)
elif ink_size == 2:
grid = middle(grid, x, y)
else:
grid = large(grid, x, y)
max_element = 0
count = 0
for i in range(2, 12):
for j in range(2, 12):
max_element = max(max_element, grid[i][j])
if grid[i][j] == 0:
count += 1
print(count)
print(max_element)
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s310304107 | p00026 | Accepted | paper=[[0 for i in range(10)] for j in range(10)]
#print paper
def drop(x,y):
global paper
if 0<=x<10 and 0<=y<10:
paper[y][x] += 1
return
def ink(x,y,s):
drop(x,y)
drop(x-1,y); drop(x+1,y)
drop(x,y-1); drop(x,y+1)
if s==1: return
drop(x-1,y-1); drop(x-1,y+1)
drop(x+1,y-1); drop(x+1,y+1)
if s==2: return
drop(x-2,y); drop(x+2,y)
drop(x,y-2); drop(x,y+2)
return
while True:
try:
x,y,s=map(int,raw_input().split(","))
ink(x,y,s)
except:
break
print sum([i.count(0) for i in paper])
print max([max(i) for i in paper])
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s495115400 | p00026 | Accepted | import sys
a=[[0]*10for _ in[0]*10]
p=[[(-1,0),(0,-1),(0,0),(0,1),(1,0)],[(-1,-1),(-1,1),(1,-1),(1,1)],[(-2,0),(0,-2),(0,2),(2,0)]]
for e in sys.stdin:
x,y,s=map(int,e.split(','))
for f in p[:s]:
for s,t in f:
if 0<=y+s<10 and 0<=x+t<10:a[y+s][x+t]+=1
print(sum(1 for r in a for c in r if c==0))
print(max(max(r)for r in a))
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s070528235 | p00026 | Accepted | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
board = [[0 for i in range(14)] for j in range(14)]
for l in range(0,len(N)):
x,y,s = [int(i) for i in N[l].split(",")]
x = x + 2
y = y + 2
if s >= 1:
board[x+1][y] += 1
board[x-1][y] += 1
board[x][y+1] += 1
board[x][y-1] += 1
board[x][y] += 1
if s >= 2:
board[x+1][y+1] += 1
board[x+1][y-1] += 1
board[x-1][y+1] += 1
board[x-1][y-1] += 1
if s >= 3:
board[x+2][y] += 1
board[x-2][y] += 1
board[x][y+2] += 1
board[x][y-2] += 1
a = 0
b = 0
for i in range(2,12):
for j in range(2,12):
if board[i][j] == 0:
a += 1
if board[i][j] > b:
b = board[i][j]
print(a)
print(b)
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s968296825 | p00026 | Accepted | p = [[0] * 10 for _ in range(10)]
x, y, s = 0, 0, 0
while True:
try:
x, y, s = map(int, input().split(","))
except:
break
if s >= 1:
p[x][y] += 1
for i in range(x-1, x+2, 2):
if -1 < i < 10:
p[i][y] += 1
for i in range(y-1, y+2, 2):
if -1 < i < 10:
p[x][i] += 1
if s >= 2:
for i in range(x-1, x+2, 2):
for j in range(y-1, y+2, 2):
if -1 < i < 10 and -1 < j < 10:
p[i][j] += 1
if s == 3:
for i in range(x-2, x+3, 4):
if -1 < i < 10:
p[i][y] += 1
for i in range(y-2, y+3, 4):
if -1 < i < 10:
p[x][i] += 1
cnt_0 = 0
max_inc = 0
for l in p:
cnt_0 += l.count(0)
max_inc = max(l + [max_inc])
print(cnt_0)
print(max_inc)
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s675538869 | p00026 | Accepted | import sys
lines = []
for line in sys.stdin:
lines.append(line.strip().split(','))
field = [[0 for i in range(10)] for j in range(10)]
def drop(x, y, z):
if z==1:
for i in range(-1,2):
for j in range(-1,2):
if abs(i)+abs(j)<2 and 0<=y+j<=9 and 0<=x+i<=9:
field[y+j][x+i] += 1
elif z==2:
for i in range(-1,2):
for j in range(-1,2):
if 0<=y+j<=9 and 0<=x+i<=9:
field[y+j][x+i] += 1
else:
for i in range(-2,3):
for j in range(-2,3):
if abs(i)+abs(j)<3 and 0<=y+j<=9 and 0<=x+i<=9:
field[y+j][x+i] += 1
for line in lines:
x,y,z = map(int, line)
drop(x,y,z)
n = 0
m = 0
for f in field:
for e in f:
if e > m:
m = e
if e==0:
n+=1
print(n)
print(m)
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s200978807 | p00026 | Accepted | def dot(h, w):
global area
if 0 <= h and h < 10 and 0 <= w and w < 10:
area[h][w] += 1
def sdot(h,w):
[dot(h + i, w + j) for j in range(-1, 2) for i in range(-1 + abs(j), 2 - abs(j))]
def mdot(h,w):
[dot(h + i, w + j) for j in range(-1, 2) for i in range(-1, 2)]
def ldot(h, w):
[dot(h + i, w + j) for j in range(-2, 3) for i in range(-2 + abs(j), 3 - abs(j))]
dots = (sdot, mdot, ldot)
area = [[0 for _ in range(10)] for _ in range(10)]
while True:
try:w, h, s = map(int, input().split(","))
except:break
dots[s - 1](h, w)
print(sum(i.count(0) for i in area))
print(max(max(i) for i in area))
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s076453644 | p00026 | Accepted | import sys,collections
c=[tuple([i,j]) for i in range(10) for j in range(10)]
d=[list(map(int,text.split(","))) for text in sys.stdin]
o=[]
for b in d:
if b[2]==1:
t=[tuple([b[0]+i,b[1]+j]) for i in range(-1,2) for j in range(-1,2) if (i==0 or j==0) and 0<=b[0]+i<=9 and 0<=b[1]+j<=9]
elif b[2]==2:
t=[tuple([b[0]+i,b[1]+j]) for i in range(-1,2) for j in range(-1,2) if 0<=b[0]+i<=9 and 0<=b[1]+j<=9]
elif b[2]==3:
t=[tuple([b[0]+i,b[1]+j]) for i in range(-2,3) for j in range(-2,3) if abs(i)+abs(j)<=2 and 0<=b[0]+i<=9 and 0<=b[1]+j<=9]
o+=t
print(len(set(c)-set(o)))
print(sorted(collections.Counter(o).values())[-1])
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s018207017 | p00026 | Accepted | #sheet...紙全体、sheet[x][y]は(x, y)のインクの濃さ
sheet = [[0 for _ in range(10)] for _ in range(10)]
#小、中、大のインクの範囲
small_range = ((0, 0), (1, 0), (0, 1), (-1, 0), (0, -1))
middle_range = ((0, 0), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1))
large_range = ((0, 0), (1, 0), (2, 0), (1, 1), (0, 1), (0, 2), (-1, 1), (-1, 0), (-2, 0), (-1, -1), (0, -1), (0, -2), (1, -1))
#範囲内か判定してインクを足す
def drop(x, y, drop_range):
for dx, dy in drop_range:
newx, newy = x + dx, y + dy
if 0 <= newx <= 9 and 0 <= newy <= 9:
sheet[newx][newy] += 1
while True:
try:
x, y, s = map(int, input().split(","))
if s == 1:
drop(x, y, small_range)
elif s == 2:
drop(x, y, middle_range)
else:
drop(x, y, large_range)
except EOFError:
break
#0の個数
zero_cnt = 0
#インクの最大値
max_ink = 0
for x in range(10):
for y in range(10):
ink = sheet[x][y]
if ink == 0:
zero_cnt += 1
if max_ink < ink:
max_ink = ink
print(zero_cnt)
print(max_ink)
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s540200695 | p00026 | Accepted | # AOJ 0026 Dropping Ink
# Python3 2018.6.15 bal4u
paper = [[0 for i in range(15)] for j in range(15)]
base = 2
while True:
try:
x, y, s = list(map(int, input().split(',')))
except EOFError:
break
x += 2
y += 2
if s == 3:
paper[x-2][y] += 1
paper[x+2][y] += 1
paper[x][y-2] += 1
paper[x][y+2] += 1
if s >= 2:
paper[x-1][y-1] += 1
paper[x-1][y+1] += 1
paper[x+1][y-1] += 1
paper[x+1][y+1] += 1
paper[x][y] += 1
paper[x-1][y] += 1
paper[x+1][y] += 1
paper[x][y-1] += 1
paper[x][y+1] += 1
cnt = max = 0;
for x in range(2, 12):
for y in range(2, 12):
if paper[x][y] == 0:
cnt += 1
if paper[x][y] > max:
max = paper[x][y]
print(cnt, max, sep='\n')
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s327624379 | p00026 | Accepted | import sys
paper = [[0] * 10 for x in xrange(10)]
def dropInc(coord, size):
x, y = coord
if size == 1:
paper[y][x] += 1
if y > 0:
paper[y-1][x] += 1
if y < 9:
paper[y+1][x] += 1
if x > 0:
paper[y][x-1] += 1
if x < 9:
paper[y][x+1] += 1
elif size == 2:
dropInc(coord, 1)
if y > 0 and x > 0:
paper[y-1][x-1] += 1
if x < 9 and y > 0:
paper[y-1][x+1] += 1
if x > 0 and y < 9:
paper[y+1][x-1] += 1
if x < 9 and y < 9:
paper[y+1][x+1] += 1
elif size == 3:
dropInc(coord, 2)
if x > 1:
paper[y][x-2] += 1
if x < 8:
paper[y][x+2] += 1
if y > 1:
paper[y-2][x] += 1
if y < 8:
paper[y+2][x] += 1
for line in sys.stdin.readlines():
line = line.strip()
x,y,size = map(int, line.split(","))
dropInc((x,y), size)
print sum([1 if x == 0 else 0 for y in paper for x in y])
print max([x for y in paper for x in y]) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s669007460 | p00026 | Accepted | drops = {
1: ((0,0,0,0,0), (0,0,1,0,0), (0,1,1,1,0), (0,0,1,0,0), (0,0,0,0,0)),
2: ((0,0,0,0,0), (0,1,1,1,0), (0,1,1,1,0), (0,1,1,1,0), (0,0,0,0,0)),
3: ((0,0,1,0,0), (0,1,1,1,0), (1,1,1,1,1), (0,1,1,1,0), (0,0,1,0,0))}
paper = [[0 for i in xrange(14)] for j in xrange(14)]
def solve(x, y, size):
for i in xrange(5):
for j in xrange(5):
if drops[size][i][j] == 1:
paper[y+i][x+j] += 1
while True:
try:
line = raw_input()
except EOFError:
break
x, y, size = map(int, line.split(','))
solve(x, y, size)
s = c = 0
for i in range(2, 12):
for j in range(2, 12):
if paper[i][j] == 0:
c += 1
if s < paper[i][j]:
s = paper[i][j]
print c
print s | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s044747357 | p00026 | Accepted | drops = {
1: ((0,0,0,0,0), (0,0,1,0,0), (0,1,1,1,0), (0,0,1,0,0), (0,0,0,0,0)),
2: ((0,0,0,0,0), (0,1,1,1,0), (0,1,1,1,0), (0,1,1,1,0), (0,0,0,0,0)),
3: ((0,0,1,0,0), (0,1,1,1,0), (1,1,1,1,1), (0,1,1,1,0), (0,0,1,0,0))}
paper = [[0] * 14 for j in xrange(14)]
def solve(x, y, size):
for i in xrange(5):
for j in xrange(5):
if drops[size][i][j] == 1:
paper[y+i][x+j] += 1
while True:
try:
line = raw_input()
except EOFError:
break
solve(*map(int, line.split(',')))
result = [f for i in [l[2:12] for l in paper[2:12]] for f in i]
print result.count(0)
print max(result) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s902544209 | p00026 | Accepted | import sys
board=[[0]*10 for i in xrange(10)]
large=[[0,0,1,0,0],
[0,1,1,1,0],
[1,1,1,1,1],
[0,1,1,1,0],
[0,0,1,0,0],]
middle=[[0,0,0,0,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,0,0,0,0],]
small=[[0,0,0,0,0],
[0,0,1,0,0],
[0,1,1,1,0],
[0,0,1,0,0],
[0,0,0,0,0],]
size=[0,small,middle,large]
def isOnBoard(y,x):
return 0<=y<10 and 0<=x<10
for line in sys.stdin.readlines():
x,y,s=map(int,line.strip().split(","))
for i in xrange(-2,3):
for j in xrange(-2,3):
if isOnBoard(y+i,x+j):
board[y+i][x+j]+=size[s][i+2][j+2]
print sum([1 if i==0 else 0 for j in board for i in j])
print max([i for j in board for i in j])
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s247938952 | p00026 | Accepted | import sys
board=[[0]*10 for i in xrange(10)]
large=[[0,0,1,0,0],
[0,1,1,1,0],
[1,1,1,1,1],
[0,1,1,1,0],
[0,0,1,0,0],]
middle=[[0,0,0,0,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,0,0,0,0],]
small=[[0,0,0,0,0],
[0,0,1,0,0],
[0,1,1,1,0],
[0,0,1,0,0],
[0,0,0,0,0],]
size=[0,small,middle,large]
def isOnBoard(y,x):
return 0<=y<10 and 0<=x<10
for line in sys.stdin.readlines():
x,y,s=map(int,line.strip().split(","))
for i in xrange(-2,3):
for j in xrange(-2,3):
if isOnBoard(y+i,x+j):
board[y+i][x+j]+=size[s][i+2][j+2]
print len([j for i in board for j in i if j==0])
print max([i for j in board for i in j]) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s063315454 | p00026 | Accepted | import sys
board=[[0]*10 for i in xrange(10)]
large=[[0,0,1,0,0],
[0,1,1,1,0],
[1,1,1,1,1],
[0,1,1,1,0],
[0,0,1,0,0],]
middle=[[0,0,0,0,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,0,0,0,0],]
small=[[0,0,0,0,0],
[0,0,1,0,0],
[0,1,1,1,0],
[0,0,1,0,0],
[0,0,0,0,0],]
size=[0,small,middle,large]
def isOnBoard(y,x):
return 0<=y<10 and 0<=x<10
for line in sys.stdin.readlines():
x,y,s=map(int,line.strip().split(","))
for i in xrange(-2,3):
for j in xrange(-2,3):
if isOnBoard(y+i,x+j):
board[y+i][x+j]+=size[s][i+2][j+2]
print len([j for i in board for j in i if j==0])
print max([j for i in board for j in i]) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s565505001 | p00026 | Accepted | import sys
board=[[0]*10 for i in xrange(10)]
large=[[0,0,1,0,0],
[0,1,1,1,0],
[1,1,1,1,1],
[0,1,1,1,0],
[0,0,1,0,0],]
middle=[[0,0,0,0,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,0,0,0,0],]
small=[[0,0,0,0,0],
[0,0,1,0,0],
[0,1,1,1,0],
[0,0,1,0,0],
[0,0,0,0,0],]
size=[0,small,middle,large]
def isOnBoard(y,x):
return 0<=y<10 and 0<=x<10
for line in sys.stdin.readlines():
x,y,s=map(int,line.strip().split(","))
for i in xrange(-2,3):
for j in xrange(-2,3):
if isOnBoard(y+i,x+j):
board[y+i][x+j]+=size[s][i+2][j+2]
a=[j for i in board for j in i]
print a.count(0)
print max(a) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s848725089 | p00026 | Accepted | cell = [[0] * 10 for i in xrange(10)]
large = [[0,0,1,0,0],
[0,1,1,1,0],
[1,1,1,1,1],
[0,1,1,1,0],
[0,0,1,0,0]]
medium= [[0,0,0,0,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,1,1,1,0],
[0,0,0,0,0]]
small = [[0,0,0,0,0],
[0,0,1,0,0],
[0,1,1,1,0],
[0,0,1,0,0],
[0,0,0,0,0]]
size = [0,small,medium,large]
while True:
try:
x, y, s = [int(i) for i in raw_input().split(',')]
except EOFError:
break
except ValueError:
break
p = size[s]
for i in xrange(5):
for j in xrange(5):
px = i+x-2
py = j+y-2
if(px in xrange(10) and py in xrange(10)):
cell[py][px] += p[i][j]
print reduce(lambda x,y:x+y,map(lambda x:x.count(0),cell))
print max(map(max,cell)) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s264502832 | p00026 | Accepted | from __future__ import (absolute_import, division, print_function,
unicode_literals)
from sys import stdin
from collections import Counter
NUM = [[0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0],
[0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
paper = Counter()
for line in stdin:
if not line.strip():
break
x, y, size = (int(s) for s in line.split(','))
xidx = [x, x-1, x, x+1, x-2, x-1, x, x+1, x+2, x-1, x, x+1, x]
yidx = [y-2, y-1, y-1, y-1, y, y, y, y, y, y+1, y+1, y+1, y+2]
val = NUM[size-1]
for a, b, i in zip(xidx, yidx, xrange(len(xidx))):
if a < 0 or 9 < a or b < 0 or 9 < b:
continue
paper[a + b * 10] += val[i]
print(sum(1 for i in xrange(100) if not paper[i]))
print(max(paper[i] for i in xrange(100))) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s963007964 | p00026 | Accepted | mass = [[0 for p in xrange(14)] for q in xrange(14)]
while True:
try:
x,y,size = map(int,raw_input().split(','))
x += 2 ; y += 2
if size == 1:
mass[x-2][y-2]+=0;mass[x-1][y-2]+=0;mass[x][y-2]+=0;mass[x+1][y-2]+=0;mass[x+2][y-2]+=0
mass[x-2][y-1]+=0;mass[x-1][y-1]+=0;mass[x][y-1]+=1;mass[x+1][y-1]+=0;mass[x+2][y-1]+=0
mass[x-2][y] +=0;mass[x-1][y] +=1;mass[x][y] +=1;mass[x+1][y] +=1;mass[x+2][y] +=0
mass[x-2][y+1]+=0;mass[x-1][y+1]+=0;mass[x][y+1]+=1;mass[x+1][y+1]+=0;mass[x+2][y+1]+=0
mass[x-2][y+2]+=0;mass[x-1][y+2]+=0;mass[x][y+2]+=0;mass[x+1][y+2]+=0;mass[x+2][y+2]+=0
elif size == 2:
mass[x-2][y-2]+=0;mass[x-1][y-2]+=0;mass[x][y-2]+=0;mass[x+1][y-2]+=0;mass[x+2][y-2]+=0
mass[x-2][y-1]+=0;mass[x-1][y-1]+=1;mass[x][y-1]+=1;mass[x+1][y-1]+=1;mass[x+2][y-1]+=0
mass[x-2][y] +=0;mass[x-1][y] +=1;mass[x][y] +=1;mass[x+1][y] +=1;mass[x+2][y] +=0
mass[x-2][y+1]+=0;mass[x-1][y+1]+=1;mass[x][y+1]+=1;mass[x+1][y+1]+=1;mass[x+2][y+1]+=0
mass[x-2][y+2]+=0;mass[x-1][y+2]+=0;mass[x][y+2]+=0;mass[x+1][y+2]+=0;mass[x+2][y+2]+=0
elif size == 3:
mass[x-2][y-2]+=0;mass[x-1][y-2]+=0;mass[x][y-2]+=1;mass[x+1][y-2]+=0;mass[x+2][y-2]+=0
mass[x-2][y-1]+=0;mass[x-1][y-1]+=1;mass[x][y-1]+=1;mass[x+1][y-1]+=1;mass[x+2][y-1]+=0
mass[x-2][y] +=1;mass[x-1][y] +=1;mass[x][y] +=1;mass[x+1][y] +=1;mass[x+2][y] +=1
mass[x-2][y+1]+=0;mass[x-1][y+1]+=1;mass[x][y+1]+=1;mass[x+1][y+1]+=1;mass[x+2][y+1]+=0
mass[x-2][y+2]+=0;mass[x-1][y+2]+=0;mass[x][y+2]+=1;mass[x+1][y+2]+=0;mass[x+2][y+2]+=0
except: break
white = 0
max = 0
for p in xrange(2,12):
for q in xrange(2,12):
if mass[p][q] == 0: white += 1
if mass[p][q] > max: max = mass[p][q]
print white
print max | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s627901911 | p00026 | Accepted |
import sys
class Paper:
def __init__(self):
self.paper = [[0 for x in range(10)] for y in range(10)]
def white_space(self):
s = 0
for x in range(10):
for y in range(10):
if self.paper[x][y] == 0:
s += 1
return s
def most_dark(self):
s = 0
for x in range(10):
for y in range(10):
if self.paper[x][y] > s:
s = self.paper[x][y]
return s
def drop(self, x, y, size):
r = []
if size == 1:
r.append((x,y))
r.append((x-1,y))
r.append((x+1,y))
r.append((x,y-1))
r.append((x,y+1))
elif size == 2:
r = [(i,j) for i in range(x-1, x+2) for j in range(y-1, y+2)]
elif size == 3:
r = [(i,j) for i in range(x-1, x+2) for j in range(y-1, y+2)]
r.append((x-2, y))
r.append((x+2, y))
r.append((x, y-2))
r.append((x, y+2))
else:
pass
# print r
r = filter(self.out_of_paper, r)
# print r
try:
for p in r:
self.paper[p[0]][p[1]] += 1
except:
pass
return self
def out_of_paper(self, p):
if 0 <= p[0] < 10 and 0 <= p[1] < 10:
return True
else:
return False
paper = Paper()
for line in sys.stdin:
(x, y, size) = tuple(map(int, line.split(',')))
paper.drop(x, y, size)
print paper.white_space()
print paper.most_dark() | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s786661494 | p00026 | Accepted | def drop(x,y):
global paper
if 0<=x<10 and 0<=y<10: paper[y][x]+=1
return
def ink(x,y,size):
drop(x,y)
drop(x-1,y)
drop(x+1,y)
drop(x,y-1)
drop(x,y+1)
if size==1: return
drop(x-1,y-1)
drop(x-1,y+1)
drop(x+1,y-1)
drop(x+1,y+1)
if size==2: return
drop(x-2,y)
drop(x+2,y)
drop(x,y-2)
drop(x,y+2)
return
paper = [[0 for i in range(10)] for j in range(10)]
while True:
try:
x,y,size = map(int, raw_input().split(","))
ink(x,y,size)
except:
break
print sum([e.count(0) for e in paper])
print max([max(e) for e in paper]) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s191726062 | p00026 | Accepted | px = ((0,0,-1,1), (-1,-1,1,1), (0,0,-2,2))
py = ((-1,1,0,0), (-1,1,-1,1), (-2,2,0,0))
p = [[0]*14 for i in range(14)]
while True:
try:
x,y,s = map(int,raw_input().split(','))
x += 2
y += 2
p[x][y] += 1
for i in range(s):
for j in range(4):
p[x+px[i][j]][y+py[i][j]] += 1
except EOFError:
break
p = [a[2:-2] for a in p[2:-2]]
print sum([a.count(0) for a in p])
print max([max(a) for a in p]) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s182949968 | p00026 | Accepted | import sys
SIZE = 10
paper = []
def main():
init()
for line in sys.stdin:
data = line.strip().split(',')
i = int(data[0])
j = int(data[1])
size = int(data[2])
if size == 1:
drop_small(i, j)
elif size == 2:
drop_medium(i, j)
elif size == 3:
drop_large(i, j)
print count_white()
print find_max()
def find_max():
mx = 0
for i in xrange(SIZE):
for j in xrange(SIZE):
mx = max(mx, paper[i][j])
return mx
def count_white():
c = 0
for i in xrange(SIZE):
for j in xrange(SIZE):
if paper[i][j] == 0:
c += 1
return c
def init():
global paper
for i in xrange(SIZE):
paper.append([0]*SIZE)
def check(i, j):
if i < 0 or SIZE <= i:
return False
if j < 0 or SIZE <= j:
return False
return True
def drop(i, j):
global paper
if not check(i, j):
return False
paper[i][j] += 1
return True
def drop_small(i, j):
drop(i, j)
drop(i - 1, j)
drop(i + 1, j)
drop(i, j - 1)
drop(i, j + 1)
def drop_medium(i, j):
drop_small(i, j)
drop(i - 1, j - 1)
drop(i - 1, j + 1)
drop(i + 1, j - 1)
drop(i + 1, j + 1)
def drop_large(i, j):
drop_medium(i, j)
drop(i - 2, j)
drop(i, j - 2)
drop(i, j + 2)
drop(i + 2, j)
main() | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s446582173 | p00026 | Accepted | paper = [[0 for i in range(10)] for j in range(10)]
def drop(x,y):
global paper
if 0 <= x < 10 and 0<= y < 10:
paper[y][x] += 1
return
def ink(x,y,s):
drop(x,y)
drop(x+1,y); drop(x,y+1)
drop(x-1,y); drop(x,y-1)
if s == 1: return
drop(x+1,y+1); drop(x+1,y-1)
drop(x-1,y+1); drop(x-1,y-1)
if s == 2: return
drop(x+2,y); drop(x,y+2)
drop(x-2,y); drop(x,y-2)
return
while True:
try:
x, y, s = map(int, raw_input().split(","))
ink(x,y,s)
except:
break
print sum([i.count(0) for i in paper])
print max([max(i) for i in paper]) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s131372400 | p00026 | Accepted | import sys
def ink(x,y,size):
global paper
paper[y][x]+=1
for d in [-1,1]:
paper[y+d][x]+=1
paper[y][x+d]+=1
if size==1: return
for d in [-1,1]:
paper[y+d][x+d]+=1
paper[y+d][x-d]+=1
if size==2: return
for d in [-2,2]:
paper[y+d][x]+=1
paper[y][x+d]+=1
return
R=range(14)
paper=[[0 for i in R] for j in R]
for s in sys.stdin:
x,y,size = map(int, s.split(","))
ink(x+2,y+2,size)
c=0
m=0
for e in paper[2:-2]:
x=e[2:-2]
c+=x.count(0)
m=max(max(x),m)
print c
print m | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s820713417 | p00026 | Accepted | import sys
def ink(x,y,size):
global P
P[y][x]+=1
for d in [-1,1]:
P[y+d][x]+=1
P[y][x+d]+=1
if size==1: return
for d in [-1,1]:
P[y+d][x+d]+=1
P[y+d][x-d]+=1
if size==2: return
for d in [-2,2]:
P[y+d][x]+=1
P[y][x+d]+=1
return
R=range(14)
P=[[0 for i in R] for j in R]
for s in sys.stdin:
x,y,size = map(int, s.split(","))
ink(x+2,y+2,size)
c=0
m=0
for e in P[2:-2]:
x=e[2:-2]
c+=x.count(0)
m=max(max(x),m)
print c
print m | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s911156694 | p00026 | Accepted | import sys
def ink(x,y,s):
global P
P[y][x]+=1
P[y+1][x]+=1
P[y-1][x]+=1
P[y][x+1]+=1
P[y][x-1]+=1
if s==1: return
P[y+1][x+1]+=1
P[y+1][x-1]+=1
P[y-1][x+1]+=1
P[y-1][x-1]+=1
if s==2: return
P[y+2][x]+=1
P[y-2][x]+=1
P[y][x+2]+=1
P[y][x-2]+=1
return
P=[[0]*14 for j in range(14)]
for s in sys.stdin:
x,y,s = map(int, s.split(","))
ink(x+2,y+2,s)
c=0
m=0
for e in P[2:-2]:
x=e[2:-2]
c+=x.count(0)
m=max(max(x),m)
print c
print m | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s957435139 | p00026 | Accepted | small_x = [-1, 0, 0, 1]
small_y = [0, -1, 1, 0]
middle_x = [-1, -1, -1, 0, 0, 1, 1, 1]
middle_y = [-1, 0, 1, -1, 1, -1, 0, 1]
big_x = [-2, -1, -1, -1, 0, 0, 0, 0, 1, 1, 1, 2]
big_y = [0, -1, 0, 1, -2, -1, 1, 2, -1, 0, 1, 0]
dx = [[], small_x, middle_x, big_x]
dy = [[], small_y, middle_y, big_y]
field = [[0] * 10 for _ in range(10)]
while 1:
try:
x1, y1, size = map(int, raw_input().split(','))
field[y1][x1] += 1
for k in range(len(dx[size])):
ny = y1 + dy[size][k]
nx = x1 + dx[size][k]
if nx < 0 or ny < 0 or nx >= 10 or ny >= 10:
continue
field[ny][nx] += 1
except:
break
ret, mx = 0, 0
for i in range(10):
for j in range(10):
if field[i][j] == 0:
ret += 1
mx = max(mx, field[i][j])
print ret
print mx | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s850777978 | p00026 | Accepted | dx = [[0, 1, 0, -1, 0], [1, 1, -1, -1], [2, 0, -2, 0]]
dy = [[0, 0, 1, 0, -1], [-1, 1, 1, -1], [0, 2, 0, -2]]
a = [[0 for i in range(14)] for j in range(14)]
try:
while True:
x, y, s = map(int, raw_input().split(','))
x += 2
y += 2
for i in range(s):
for j in range(len(dx[i])):
a[x + dx[i][j]][y + dy[i][j]] += 1
except:
pass
ct = mx = 0
for b in a[2:-2]:
for p in b[2:-2]:
mx = max(mx, p)
if p == 0:
ct += 1
print ct
print mx | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s383072593 | p00026 | Accepted | import sys
def plot(x, y):
global ban
if 0 <= x < 10 and 0 <= y < 10: ban[y][x] += 1
def drop(x, y, s):
for dx, dy in [(0, 0), (-1, 0), (1, 0), (0, -1), (0, 1)]:
plot(x + dx, y + dy)
if s == 1: return
for dx, dy in [(-1, -1), (-1, 1), (1, -1), (1, 1)]:
plot(x + dx, y + dy)
if s == 2: return
for dx, dy in [(-2, 0), (2, 0), (0, -2), (0, 2)]:
plot(x + dx, y + dy)
ban = [[0 for x in range(10)] for y in range(10)]
for line in sys.stdin:
x, y, size = map(int, line.split(','))
drop(x, y, size)
print(sum(ban[y][x] == 0 for y in range(10) for x in range(10)))
print(max(ban[y][x] for y in range(10) for x in range(10))) | 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s082020694 | p00026 | Accepted | mat = []
for i in range(10):
mat.append([0]*10)
while True:
try:
lst = list(map(int, input().split(',')))
x, y, s = lst[0], lst[1], lst[2]
if s == 1:
tmplst = [[x, y], [x, y-1], [x-1, y], [x+1, y], [x, y+1]]
elif s == 2:
tmplst = [[x, y], [x, y-1], [x-1, y], [x+1, y], [x, y+1], [x-1, y-1], [x+1, y-1], [x-1, y+1], [x+1, y+1]]
else:
tmplst = [[x, y], [x, y-1], [x-1, y], [x+1, y], [x, y+1], [x-1, y-1], [x+1, y-1], [x-1, y+1], [x+1, y+1], [x, y-2], [x-2, y], [x+2, y], [x, y+2]]
for i in tmplst:
if i[0] < 0 or i[0] > 9 or i[1] < 0 or i[1] > 9:
pass
else:
mat[i[1]][i[0]] +=1
except EOFError:
break
summat = 0
maxmat = 0
for j in mat:
summat += j.count(0)
if maxmat < max(j):
maxmat = max(j)
print(summat)
print(maxmat)
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s568071631 | p00026 | Accepted | import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
def solve():
P = []
for line in readlines():
x, y, s = map(int, line.split(","))
P.append((x, y, s))
L = 10
MP = [[0]*L for i in range(L)]
def update(k, ps):
for x, y, s in P:
if k <= s:
for dx, dy in ps:
nx = x + dx; ny = y + dy
if not 0 <= nx < L or not 0 <= ny < L:
continue
MP[ny][nx] += 1
update(0, [(0, 0)])
update(1, [(-1, 0), (0, -1), (1, 0), (0, 1)])
update(2, [(-1, -1), (1, -1), (-1, 1), (1, 1)])
update(3, [(-2, 0), (0, -2), (2, 0), (0, 2)])
z = m = 0
for i in range(L):
for j in range(L):
if MP[i][j] == 0:
z += 1
m = max(m, MP[i][j])
write("%d\n%d\n" % (z, m))
solve()
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s207760292 | p00026 | Accepted | paper = [[0 for i in range(10)] for j in range(10)]
while True :
try :
x, y, s = map(int, input().split(","))
paper[x][y] += 1
if x > 0 :
paper[x-1][y] += 1
if y > 0 :
paper[x][y-1] += 1
if x < 9 :
paper[x+1][y] += 1
if y < 9 :
paper[x][y+1] += 1
if s > 1 :
if x > 0 :
if y > 0 :
paper[x-1][y-1] += 1
if y < 9 :
paper[x-1][y+1] += 1
if x < 9 :
if y > 0 :
paper[x+1][y-1] += 1
if y < 9 :
paper[x+1][y+1] += 1
if s > 2 :
if x > 1 :
paper[x-2][y] += 1
if y > 1 :
paper[x][y-2] += 1
if x < 8 :
paper[x+2][y] += 1
if y < 8 :
paper[x][y+2] += 1
except EOFError :
break
S = 0
M = 0
for i in range(10) :
for j in range(10) :
if paper[i][j] == 0 :
S += 1
if paper[i][j] > M :
M = paper[i][j]
print(S)
print(M)
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
s713299026 | p00026 | Accepted | def solve():
from sys import stdin
input_lines = stdin
paper = [0] * 196
size = [[0, -1, 1, -14, 14], [0, -1, 1, -15, -14, -13, 13, 14, 15],
[0, -1, 1, -15, -14, -13, 13, 14, 15, -28, -2, 2, 28]]
for line in input_lines:
x, y, s = map(int, line.split(','))
pos = 30 + x + 14 * y
s -= 1
for move in size[s]:
paper[pos+move] += 1
zero_cnt = 0
max_density = 0
for i in range(30, 157, 14):
line = paper[i:i+10]
zero_cnt += line.count(0)
max_density = max(max_density, max(line))
print(zero_cnt)
print(max_density)
solve()
| 2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
| 77
5
|
<H1>Dropping Ink</H1>
<p>
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (<var>x</var>, <var>y</var>) coordinate system.
</p>
<p>
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1"></center>
<br/>
<p>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2"></center>
<br/>
<p>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
</p>
<p>
Your task is to write a program which reads a sequence of points of fall (<var>x</var>, <var>y</var>) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
</p>
<p>
You may assume that the paper always consists of 10 × 10, and 0 ≤ <var>x</var> < 10, 0 ≤ <var>y</var> < 10.
</p>
<H2>Input</H2>
<pre>
<var>x<sub>1</sub></var>,<var>y<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>x<sub>2</sub></var>,<var>y<sub>2</sub></var>,<var>s<sub>2</sub></var>
:
:
</pre>
<p>
(<var>x<sub>i</sub></var>, <var>y<sub>i</sub></var>) represents the position of the <var>i</var>-th drop and <var>s<sub>i</sub></var> denotes its size. The number of drops is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
Print the number of cells whose density value is 0 in first line.<br>
Print the maximum value of density in the second line.
</p>
<H2>Sample Input</H2>
<pre>
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
77
5
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.