Go: package main

import (
        "fmt"
)

var paper [10][10]int

func main() {
        var x, y, s int
        for {
                _, err := fmt.Scanf("%d,%d,%d", &x, &y, &s)
                if err != nil {
                        break
                }

                fill(x, y, s)
        }
        var d, z int
        for i := 0; i < 10; i++ {
                for j := 0; j < 10; j++ {
                        if paper[i][j] == 0 {
                                z += 1
                        }
                        if paper[i][j] > d {
                                d += 1
                        }
                }
        }
        fmt.Printf("%d\n%d\n", z, d)
}

func fill(x int, y int, s int) {
        paper[x][y] += 1
        if x > 0 {
                paper[x-1][y] += 1
        }
        if x < 9 {
                paper[x+1][y] += 1
        }
        if y > 0 {
                paper[x][y-1] += 1
        }
        if y < 9 {
                paper[x][y+1] += 1
        }

        if s >= 2 {
                if x > 0 && y > 0 {
                        paper[x-1][y-1] += 1
                }
                if x > 0 && y < 9 {
                        paper[x-1][y+1] += 1
                }
                if x < 9 && y > 0 {
                        paper[x+1][y-1] += 1
                }
                if x < 9 && y < 9 {
                        paper[x+1][y+1] += 1
                }
        }

        if s > 2 {
                if x > 1 {
                        paper[x-2][y] += 1
                }
                if x < 8 {
                        paper[x+2][y] += 1
                }
                if y > 1 {
                        paper[x][y-2] += 1
                }
                if y < 8 {
                        paper[x][y+2] += 1
                }
        }
}

C++: #include <iostream>
#include <cstdio>
#include <vector>

enum DropSize {
	DropSize_S = 1,
	DropSize_M,
	DropSize_L
};

struct SinkCell {
	int x, y;
};

SinkCell sinkCellsForSizeS[] = {
	{0,0},{-1,0},{1,0},{0,-1},{0,1}
};
SinkCell sinkCellsForSizeM[] = {
	{-1,-1},{0,-1},{1,-1},{-1,0},{0,0},{1,0},{-1,1},{0,1},{1,1}
};
SinkCell sinkCellsForSizeL[] = {
	{0,-2},{-1,-1},{0,-1},{1,-1},{-2,0},{-1,0},{0,0},{1,0},{2,0},{-1,1},{0,1},{1,1},{0,2}
};

class Paper {
	int width_;
	int height_;
	std::vector<int> depth_;
	void SinkInk(int x, int y) {
		if (0 <= x && x < width_ && 0 <= y && y < height_) {
			++depth_[width_ * x + y];
		}
	}
	template<int count>
	void SinkInkToCells(int x, int y, const SinkCell (&cells)[count]) {
		for (int i = 0; i < count; ++i) {
			SinkInk(x + cells[i].x, y + cells[i].y);
		}
	}
public:
	explicit Paper(int width, int height) : width_(width), height_(height), depth_(width * height, 0)
	{
	}
	void DropInk(int x, int y, DropSize size)
	{
		if (0 <= x && x < width_ && 0 <= y && y < height_) {
			switch (size) {
				case DropSize_S:
					SinkInkToCells(x, y, sinkCellsForSizeS);
					break;
				case DropSize_M:
					SinkInkToCells(x, y, sinkCellsForSizeM);
					break;
				case DropSize_L:
					SinkInkToCells(x, y, sinkCellsForSizeL);
					break;
				default:
					break;
			}
		}
	}
	int Depth(int x, int y) const
	{
		return depth_[width_ * x + y];
	}
private:
};

int main()
{
	const int width = 10;
	const int height = 10;
	Paper paper(width, height);
	int x, y, size;
	while (std::scanf("%d,%d,%d", &x, &y, &size) == 3) {
		paper.DropInk(x, y, static_cast<DropSize>(size));
	}

	int maxDepth = 0;
	int whiteCount = 0;
	for (int x = 0; x < width; ++x) {
		for (int y = 0; y < height; ++y) {
			if (maxDepth < paper.Depth(x, y)) {
				maxDepth = paper.Depth(x, y);
			}
			if (paper.Depth(x, y) == 0) {
				++whiteCount;
			}
		}
	}

	std::printf("%d\n%d\n", whiteCount, maxDepth);

	return 0;
}

C++: #include<cstdio>
#include<algorithm>
using namespace std;
int main(){
	int x, y, s;
	int chess[14][14]={0};
	while(scanf("%d,%d,%d", &x, &y, &s)!=EOF){
		x=x+2;
		y=y+2;
		if(s==1){
			chess[x][y]++;
			chess[x+1][y]++;
			chess[x-1][y]++;
			chess[x][y+1]++;
			chess[x][y-1]++;
		}
		else if(s==2){
			for(int i=x-1; i<=x+1; i++){
				for(int j=y-1; j<=y+1; j++)
					chess[i][j]++;
			}
		}
		else if(s==3){
			for(int i=x-1; i<=x+1; i++){
				for(int j=y-1; j<=y+1; j++)
					chess[i][j]++;
			}
			chess[x][y-2]++;
			chess[x][y+2]++;
			chess[x+2][y]++;
			chess[x-2][y]++;
		}
	}
	int c=0, m=0;
	for(int i=2; i<12; i++){
		for(int j=2; j<12; j++){
			if(chess[i][j]==0)
				c++;
			else{
				m=max(m, chess[i][j]);
			}
		}
	}
	printf("%d\n%d\n", c, m);
	return 0;
}

C++: #include <iostream>
#include <stdio.h>
using namespace std;

void solve()
{
	int dx[] = {1, 0, -1, 0, 1, 1, -1, -1, 2, 0, -2, 0};
	int dy[] = {0, -1, 0, 1, 1, -1, 1, -1, 0, -2, 0, 2};
	int field[10][10] = {0};
	int x, y, size;
	while(scanf("%d,%d,%d", &x, &y, &size) != EOF)
	{
		++field[x][y];
		int n = 4 * size;
		for(int i = 0; i < n; ++i)
		{
			if((0 <= x + dx[i] && x + dx[i] < 10) && (0 <= y + dy[i] && y + dy[i] < 10))
			{
				++field[x + dx[i]][y + dy[i]];
			}
		}
	}
	int count = 0;
	int max = 0;
	for(int i = 0; i < 10; ++i)
	{
		for(int j = 0; j < 10; ++j)
		{
			if(field[i][j] >= 1)
			{
				++count;
			}
			if(field[i][j] > max)
			{
				max = field[i][j];
			}
		}
	}
	cout << 100 - count << endl;
	cout << max << endl;
}

int main()
{
	solve();
	return(0);
}

C++: import Control.Monad
import qualified Data.Array.Unboxed as A
import qualified Data.Array.ST as AS
import Data.List

data Drop = Small | Middle | Large deriving (Enum)
spread :: Drop -> (Int,Int) -> [(Int,Int)]
spread Small = neighbours 1
spread Middle = \(x,y) -> [(x+i,y+j) | i <- [-1..1], j <- [-1..1]]
spread Large = neighbours 2

neighbours :: Int -> (Int,Int) -> [(Int,Int)]
neighbours n (x,y) =
        [(x+i,y+j) | i <- [-n..n], let jw = n - abs i, j <- [-jw..jw]]

dropInk :: [((Int,Int), Drop)] -> A.UArray (Int,Int) Int
dropInk ds = AS.runSTUArray $ do
    paper <- AS.newArray ((0,0), (9,9)) 0
    forM_ ds $ \ (loc, d) ->
        forM_ (spread d loc) $ \ stain ->
            unless (outside stain) $
                AS.readArray paper stain >>= AS.writeArray paper stain . succ
    return paper

outside :: (Int,Int) -> Bool
outside (x,y) = not $ x `elem` [0..9] && y `elem` [0..9]

parseLine :: String -> ((Int,Int), Drop)
parseLine s = let (x:y:d:_) = map read . splitWith ',' $ s
                in ((x,y), toEnum (d-1))

splitWith :: Eq a => a -> [a] -> [[a]]
splitWith c = unfoldr f where
    f [] = Nothing
    f xs = let (pre,post) = break (== c) xs in
        Just (pre, drop 1 post)

main = do
    paper <- A.elems .  dropInk . map parseLine . lines <$> getContents
    print . length . filter (== 0) $ paper
    print . maximum $ paper

C++: #include <iostream>
#include <set>
using namespace std;

int main(){
  int smallx[5] = {0,1,0,-1,0};
  int smally[5] = {0,0,1,0,-1};
  int middlex[9] = {0,0,0,-1,-1,-1,1,1,1};
  int middley[9] = {0,-1,1,0,-1,1,0,-1,1};
  int largex[13] = {0,2,1,1,1,0,0,0,0,-1,-1,-1,-2};
  int largey[13] = {0,0,1,0,-1,2,1,-1,-2,1,0,-1,0};
  char cc;
  int a,b,c,x,y;
  int max = 0;
  int plot[10][10];
  for(int y=0;y<10;y++){
    for(int x=0;x<10;x++){
      plot[x][y] = 0;
    }
  }
  int paint = 0;
  while(cin>>a>>cc>>b>>cc>>c){
    if (c==1){
      for(int i=0;i<5;i++){
	x = a+smallx[i];
	y = b+smally[i];
	if(0<=x&&0<=y&&x<10&&y<10){
	  if (plot[x][y] == 0)paint++;
	  plot[x][y]++;
	  if(max<plot[x][y])max=plot[x][y];
	}
      }
    }
    if (c==2){
      for(int i=0;i<9;i++){
	x = a+middlex[i];
	y = b+middley[i];
	if(0<=x&&0<=y&&x<10&&y<10){
	  if (plot[x][y] == 0)paint++;
	  plot[x][y]++;
	  if(max<plot[x][y])max=plot[x][y];
	}
      }
    }
    if (c==3){
      for(int i=0;i<13;i++){
	x = a+largex[i];
	y = b+largey[i];
	if(0<=x&&0<=y&&x<10&&y<10){
	  if (plot[x][y] == 0)paint++;
	  plot[x][y]++;
	  if(max<plot[x][y])max=plot[x][y];
	}
      }
    }
  }
  cout<<100-paint<<endl<<max<<endl;
  return 0;
}