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>
using namespace std;
int main(){
  int k[10][10]={0};
  int x,y,s,i,j;
  char c;
  int d=0,w=0;
  int S[4]={0,5,9,13};
  int X[]={0,1,-1,0,0,1,-1,1,-1,2,-2,0,0};
  int Y[]={0,0,0,1,-1,1,-1,-1,1,0,0,2,-2};
  while(cin>>x>>c>>y>>c>>s){
    for(i=0;i<S[s];i++){
      
      if(-1<x&&x<10&&-1<y&&y<10){
	if(-1<x+X[i]&&x+X[i]<10&&-1<y+Y[i]&&y+Y[i]<10){
	  k[x+X[i]][y+Y[i]]++;
	  if(k[x+X[i]][y+Y[i]]>d){
	    d=k[x+X[i]][y+Y[i]];
	  }
	}
      }
    }
  }
  for(i=0;i<10;i++){
    for(j=0;j<10;j++){
      if(k[i][j]==0)w++;
    }
  }
  if(d!=0){
    cout<<w<<"\n"<<d<<endl;
  }
  return 0;
}

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

int board[10][10];

void fill(int x, int y){
	if(0<=x && x<10 && 0<=y && y<10){
		board[y][x]++;
	}
}

int main(){
	int x, y, size;
	while(~scanf("%d,%d,%d", &x, &y, &size)){
		if(size >= 1){ // small
			fill(x, y);
			fill(x+1, y);
			fill(x-1, y);
			fill(x, y+1);
			fill(x, y-1);
		}
		if (size >= 2) { // medium
			fill(x+1, y+1);
			fill(x+1, y-1);
			fill(x-1, y+1);
			fill(x-1, y-1);
		}
		if(size >= 3){ // large
			fill(x+2, y);
			fill(x-2, y);
			fill(x, y+2);
			fill(x, y-2);
		}
	}
	int num_zero = 0;
	int deepest = 0;
	for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 10; j++) {
			if(board[j][i] == 0){
				num_zero++;
			}
			if(deepest < board[j][i]){
				deepest = board[j][i];
			}
		}
	}
	cout << num_zero << endl;
	cout << deepest << endl;

	return 0;
}

C++: #include <stdio.h>

static int ink[10][10];

int drop(int x, int y)
{
  if ((0 <= x) && (x <= 9) && (0 <= y) && (y <= 9)) {
    ++ink[x][y];
    return 1;
  } else {
    return 0;
  }
}

int white(void)
{
  int count = 0;
  int i,j;
  for (i=0; i<10; ++i) {
    for (j=0; j<10; ++j) {
      if (ink[i][j] == 0) {
        ++count;
      }
    }
  }
  return count;
}

int depth(void)
{
  int max = 0;
  int i,j;
  for (i=0; i<10; ++i) {
    for (j=0; j<10; ++j) {
      if (max < ink[i][j]) {
        max = ink[i][j];
      }
    }
  }
  return max;
}

int main(void)
{
  int i,j;
  for (i=0; i<10; ++i) {
    for (j=0; j<10; ++j) {
      ink[i][j] = 0;
    }
  }
  
  int x,y,size;
  while (scanf("%d,%d,%d", &x, &y, &size) != EOF) {
    drop(x,y);
    drop(x+1,y);
    drop(x,y+1);
    drop(x-1,y);
    drop(x,y-1);
    if (size > 1) {
      drop(x+1,y+1);
      drop(x-1,y+1);
      drop(x-1,y-1);
      drop(x+1,y-1);
    }
    if (size == 3) {
      drop(x+2,y);
      drop(x,y+2);
      drop(x-2,y);
      drop(x,y-2);
    }
  }

  printf("%d\n", white());
  printf("%d\n", depth());

  return 0;
}

C++: #include<stdio.h>
void tyu(int x,int y,int N[15][15])
{
	int xt,yt;
	xt=x-1;yt=y-1;
	for(int i=yt;i<=yt+2;i++)
		for(int j=xt;j<=xt+2;j++)
			N[i][j]++;
}
void syo(int x,int y,int N[15][15])
{
	N[y][x]++;N[y+1][x]++;N[y-1][x]++;
	N[y][x+1]++;N[y][x-1]++;
}
void dai(int x,int y,int N[15][15])
{
	int xt,yt;
	xt=x-1;yt=y-1;
	for(int i=yt;i<=yt+2;i++)
		for(int j=xt;j<=xt+2;j++)
			N[i][j]++;
	N[y+2][x]++;N[y-2][x]++;
	N[y][x+2]++;N[y][x-2]++;
}

int main()
{
	int x,y,z,PP[15][15]={},xt=0,yt=0;
	while(scanf("%d,%d,%d",&x,&y,&z)!=EOF)
	{
		xt=x+2;yt=y+2;
		if(z==1)syo(xt,yt,PP);
		else if(z==2)tyu(xt,yt,PP);
		else if(z==3)dai(xt,yt,PP);
	}
	int SUM1=0,SUM2=0,max=0;
	for(int i=2;i<12;i++){
		for(int j=2;j<12;j++){
			if(PP[i][j]==0)SUM1++;
			if(PP[i][j]>max){max=PP[i][j];SUM2=1;}
			else if(PP[i][j]==max)SUM2++;
		}
	}
	printf("%d\n%d\n",SUM1,max);

	return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <list>
#include <map>
#include <algorithm>
#include <stack>
#include <string>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>

#define DEBUG 0

using namespace std;

struct INKI{
	int x;
	int y;
	int size;
};

int main(){
	int map[10][10];

	for(int i = 0; i < 10; i++){
		for(int j = 0; j < 10; j++){
			map[i][j] = 0;
		}
	}

	INKI tmp;
	while( scanf("%d,%d,%d", &tmp.x, &tmp.y, &tmp.size) ){
		if(tmp.size == 3){
			for(int i = -2; i <= 2; i++){
				if(tmp.y + i >= 0 && tmp.y + i < 10){
					map[tmp.y + i][tmp.x]++;
				}
				if(tmp.x + i >= 0 && tmp.x + i < 10){
					map[tmp.y][tmp.x + i]++;
				}
			}
			map[tmp.y][tmp.x]--;
			for(int i = -1; i <= 1; i += 2){
				if(tmp.y + i >= 0 && tmp.y + i < 10){
					for(int j = -1; j <= 1; j += 2){
						if(tmp.x + j >= 0 && tmp.x + j < 10){
							map[tmp.y + i][tmp.x + j]++;
						}
					}
				}
			}
		}
		else if(tmp.size == 2){
			for(int i = tmp.y - 1; i <= tmp.y + 1; i++){
				if(i >= 0 && i < 10){
					for(int j = tmp.x - 1; j <= tmp.x + 1; j++){
						if(j >= 0 && j < 10){
							map[i][j]++;
						}
					}
				}
			}
		}
		else if(tmp.size == 1){
			for(int i = -1; i <= 1; i++){
				if(tmp.y + i >= 0 && tmp.y + i < 10){
					map[tmp.y + i][tmp.x]++;
				}
				if(tmp.x + i >= 0 && tmp.x + i < 10){
					map[tmp.y][tmp.x + i]++;
				}
			}
			map[tmp.y][tmp.x]--;
		}
//#if DEBUG
//		for(int i = 0; i < 10; i++){
//			for(int j = 0; j < 10; j++){
//				if(j){
//					cout << " ";
//				}
//				cout << map[i][j];
//			}
//			cout << endl;
//		}
//#endif


	}

	int noColor = 0;
	int koi = 0;

	for(int i = 0; i < 10; i++){
		for(int j = 0; j < 10; j++){
			if(map[i][j] == 0){
				noColor++;
			}
			if(koi < map[i][j]){
				koi = map[i][j];
			}
		}
	}

	cout << noColor << endl;
	cout << koi << endl;

	return 0;
}