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 <fstream>
#include <algorithm>
#include <vector>
#include <string>
#include <functional>
#include <array>
#include <stack>
#include <queue>
#include <chrono>
#include <numeric>
#include <memory.h>
#include <map>
#include <math.h>
#include <utility>
#include <set>

#pragma warning(disable:4996)
using namespace std;
#define REP(i,n) for(int i = 0 ; i < n ; ++i)
typedef long long Int;
const double PI = 3.141592653589793238;
const Int INF = 999999999999;
typedef pair<int, int> P;

int S[3][3] = {
		{ 0, 1, 0 },
		{ 1, 1, 1 },
		{ 0, 1, 0 },
};
int M[3][3] = {
		{ 1, 1, 1 },
		{ 1, 1, 1 },
		{ 1, 1, 1 },
};
int L[5][5] = {
		{ 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 },
};

int tile[10][10];

int main()
{
	int x, y, size;
	while (scanf_s("%d,%d,%d",&x,&y,&size)){
		int xt = x;
		int yt = y;
		if (size == 1){
			while (xt - 1 < 0)++xt;
			while (yt - 1 < 0)++yt;
			while (xt + 2 > 9)--xt;
			while (yt + 2 > 9)--yt;

			for (int i = yt - 1; i < yt + 2; ++i){
				for (int j = xt - 1; j < xt + 2; ++j){
					tile[i][j] += S[i + 1 - yt][j + 1 - xt];
				}
			}
		}
		if (size == 2){
			while (xt - 1 < 0)++xt;
			while (yt - 1 < 0)++yt;
			while (xt + 2 > 9)--xt;
			while (yt + 2 > 9)--yt;

			for (int i = yt - 1; i < yt + 2; ++i){
				for (int j = xt - 1; j < xt + 2; ++j){
					tile[i][j] += M[i + 1 - yt][j + 1 - xt];
				}
			}

		}
		if (size == 3){
			while (xt - 1 < 0)++xt;
			while (yt - 1 < 0)++yt;
			while (xt + 3 > 9)--xt;
			while (yt + 3  > 9)--yt;

			for (int i = yt - 2; i < yt + 3; ++i){
				for (int j = xt - 2; j < xt + 3; ++j){
					tile[i][j] += L[i + 2 - yt][j + 2 - xt];
				}
			}

		}
	}
	int white = 0;
	int max_ = -1;

	REP(i, 10){
		REP(j, 10){
			if (!tile[i][j])
				++white;
			max_ = max(tile[i][j], max_);
		}
	}

	cout << white << endl << max_ << endl;

	return 0;

}

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

int main()
{
	int xy[10][10] = {0};
	int x,y,size;
	
	while(scanf("%d,%d,%d", &x,&y,&size) != EOF){
		
		xy[y-1][x]++;
		xy[y][x-1]++;
		xy[y][x]++;
		xy[y][x+1]++;
		xy[y+1][x]++;
		
		if(size >= 2){
			xy[y-1][x-1]++;
			xy[y-1][x+1]++;
			xy[y+1][x-1]++;
			xy[y+1][x+1]++;
		}
		if(size == 3){
			xy[y-2][x]++;
			xy[y][x-2]++;
			xy[y][x+2]++;
			xy[y+2][x]++;
		}
		int w=0,con = 0;
	
	for(int i=0; i < 10; i++){
		for(int j=0; j < 10; j++){
			if(xy[i][j] == 0)w++;
			if(con < xy[i][j])con = xy[i][j];
		}
	}
	
	printf("%d\n%d\n", w, con);
	
	}
	return (0);
}

C++: #include <iostream>
#include <stdio.h>

int paper[10][10]={0};

void paint(int x, int y)
{
	if( x>=0 && y>=0 )
		paper[x][y]++;
	return;
}

void drop(int x, int y, int size)
{
	switch(size)
	{
		case 1:
			paint(x-1, y);
			paint(x+1, y);
			paint(x, y-1);
			paint(x, y+1);
			paint(x, y);
			break;
		case 2:
			drop(x,y,1);
			paint(x-1, y-1); paint(x-1, y+1);
			paint(x+1, y-1); paint(x+1, y+1);
			break;
		case 3:
			drop(x,y,2);
			paint(x-2,y);paint(x,y-2);
			paint(x+2,y);paint(x,y+2);
			break;
	}
	return;
}

int main(void)
{
	int x,y,s;
	while(~scanf("%d,%d,%d",&x,&y,&s))
		drop(x,y,s);

	int blank=0;
	int max=0;
	for(int i=0; i<10; i++)
		for(int j=0; j<10; j++)
		{
			if(paper[i][j]==0)
				blank++;
			if(paper[i][j] > max)
				max = paper[i][j];
		}
	std::cout << blank << std::endl << max << std::endl;

	return 0;
}

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

const int H = 10;
const int W = H;
int G[H][W];

int main() {
  fill(G[0], G[H], 0);
  int x, y, size;
  while(scanf("%d,%d,%d", &x, &y, &size) != EOF) {
    vector<pair<int,int> > v;
    if(size >= 1) {
      v.push_back(make_pair(0,0));
      v.push_back(make_pair(1,0));
      v.push_back(make_pair(0,1));
      v.push_back(make_pair(-1,0));
      v.push_back(make_pair(0,-1));
    }
    if(size >= 2) {
      v.push_back(make_pair(1,1));
      v.push_back(make_pair(1,-1));
      v.push_back(make_pair(-1,1));
      v.push_back(make_pair(-1,-1));
    }
    if(size >= 3) {
      v.push_back(make_pair(2,0));
      v.push_back(make_pair(0,2));
      v.push_back(make_pair(-2,0));
      v.push_back(make_pair(0,-2));
    }
    for(int i = 0; i < v.size(); ++i) {
      int nx = x + v[i].first;
      int ny = y + v[i].second;
      if(nx < 0 || nx >= W) continue;
      if(ny < 0 || ny >= H) continue;
      ++G[ny][nx];
    }
  }
  int koi = 0;
  int space = 0;
  for(int i = 0; i < H; ++i) {
    for(int j = 0; j < W; ++j) {
      space += G[i][j] == 0;
      koi = max(koi, G[i][j]);
    }
  }
  cout << space << endl;
  cout << koi << endl;
  return 0;
}

C++: #include<iostream>
using namespace std;
void big(int x,int y,int a[10][10]);
void middle(int x,int y,int a[10][10]);
void small(int x,int y,int a[10][10]);
int main(){
	int a[10][10]={0};
	int x,y,s;
	char c;
	int cnt=0,max=0;
	while(cin>>x>>c>>y>>c>>s){
	if(s==3)big(x,y,a);
	else if(s==2)middle(x,y,a);
	else if(s==1)small(x,y,a);
	
	}
	for(int i=0;i<10;i++){
		for(int j=0;j<10;j++){
			if(a[i][j]==0)cnt++;
			if(a[i][j]>max)max=a[i][j];
			//cout<<a[i][j]<<" ";
		}
		//cout<<endl;
	}
	cout<<cnt<<endl<<max<<endl;
}

void big(int x,int y,int a[10][10]){
	a[x][y]++;
	a[x-2][y]++;a[x][y-2]++;
	a[x-1][y]++;a[x][y-1]++;
	a[x+1][y]++;a[x][y+1]++;
	a[x+2][y]++;a[x][y+2]++;	
	a[x+1][y+1]++;a[x-1][y-1]++;
	a[x+1][y-1]++;a[x-1][y+1]++;
	return ;
}

void middle(int x,int y,int a[10][10]){
	a[x][y]++;
	a[x+1][y]++;a[x][y+1]++;
	a[x-1][y]++;a[x][y-1]++;
	a[x+1][y+1]++;a[x-1][y-1]++;
	a[x+1][y-1]++;a[x-1][y+1]++;
}
void small(int x,int y,int a[10][10]){
	a[x][y]++;
	a[x+1][y]++;a[x][y+1]++;
	a[x-1][y]++;a[x][y-1]++;
}