Go: package main

import (
	"bufio"
	"os"
	"strconv"
	"strings"
	"fmt"
)

var scanner = bufio.NewScanner(os.Stdin)
var (
	dat = [5000][5]int{}
	m = [5]int{}
)

func main() {
	for scanner.Scan() {
		for i := range dat {
			for j := range dat[i] {
				dat[i][j] = 0
			}
		}
		for i := range m {
			m[i] = 0
		}
		n, _ := strconv.Atoi(scanner.Text())
		if n == 0 {
			break
		}
		count := 0
		for i := 0; i < n; i++ {
			scanner.Scan()
			buf := strings.Split(scanner.Text(), " ")
			d, _ := strconv.Atoi(buf[0])
			p, _ := strconv.Atoi(buf[1])
			q, _ := strconv.Atoi(buf[2])
			q--
			count += p
			if d == 2 {
				for j := 0; j < p; j++ {
					dat[m[q]][q] = 1
					ok := true
					for k := 0; k < 5; k++ {
						if dat[m[q]][k] == 0 {
							ok = false
						}
					}
					if ok {
						for k := 0; k < 5; k++ {
							dat[m[q]][k] = 0
							for l := m[q]; l < 4999; l++ {
								dat[l][k] = dat[l+1][k]
							}
							for l := 4999; l >= 0; l-- {
								if dat[l][k] != 0 {
									m[k] = l+1
									break
								}
								if l == 0 {
									m[k] = 0
								}
							}
						}
						count -= 5
					} else {
						m[q]++
					}
				}
			} else {
				h := 0
				for i := 0; i < p; i++ {
					h = max(h, m[i+q])
				}
				for i := 0; i < p; i++ {
					dat[h][i+q] = 1
				}
				for i := 0; i < p; i++ {
					m[i+q] = h+1
				}
				ok := true
				for j := 0; j < 5; j++ {
					if dat[h][j] == 0 {
						ok = false
					}
				}
				if ok {
					for j := 0; j < 5; j++ {
						dat[h][j] = 0
						for k := h; k < 4999; k++ {
							dat[k][j]=dat[k+1][j]
						}
						for k := 4999; k>= 0; k-- {
							if dat[k][j] != 0 {
								m[j]=k+1
								break
							}
							if k == 0 {
								m[j] = 0
							}
						}
					}
					count -= 5
				}
			}
		}
		fmt.Println(count)
	}
}

func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}

C++: #include <bits/stdc++.h>

using namespace std;

char stage[2][5000][5];

int main()
{
    int n;
    
    while (scanf("%d", &n) && n){
        int height[5] = {0};
        int turn = 0;
        memset(stage, 0, sizeof(stage));
        for (int rep = 0; rep < n; rep++){
            int d, p, q;
            scanf("%d %d %d", &d, &p, &q); --q;
            if (d == 1){
                int mh = *max_element(height + q, height + p + q);
                for (int j = q; j < p + q; j++){
                    stage[turn][mh][j] = 1;
                    height[j] = mh + 1;
                }
            }
            else {
                for (int j = 0; j < p; j++){
                    stage[turn][height[q]++][q] = 1;
                }
            }
            
            int look = *max_element(height, height + 5);
            memset(height, 0, sizeof(height));
            int nh = 0;
            for (int i = 0; i < look; i++){
                bool ok = true;
                for (int j = 0; j < 5; j++){
                    if (stage[turn][i][j] == 0) ok = false;
                }
                if (!ok){
                    bool has = false;
                    memcpy(stage[1 - turn][nh], stage[turn][i], sizeof(stage[turn][i]));
                    for (int j = 0; j < 5; j++){
                        if (stage[1 - turn][nh][j]){
                            height[j] = nh + 1;
                            has = true;
                        }
                    }
                    nh += has;
                }
            }
            turn = 1 - turn;
        }
        
        int ret = 0;
        int h = *max_element(height, height + 5);
        for (int i = 0; i < h; i++){
            for (int j = 0; j < 5; j++){
                ret += stage[turn][i][j];
            }
        }
        
        printf("%d\n", ret);
    }
    
    return (0);
}

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

class TETORIS {
public:
	int N;
	vector<vector<int> > bd;
	TETORIS() : N(0) {}
	void put(int len, int pos) {
		int k = bd.size()-1;
		for (; k>=0; --k) {
			for (int i=0; i<len; ++i) {
				if (bd[k][pos+i]) goto brk;
			}
		} brk:;
		++k;
		if (bd.size() == k) bd.push_back(vector<int>(5, 0));
		for (int i=0; i<len; ++i) {
			bd[k][pos+i] = 1;
		}
		N += len;
	}
	void update() {
		for (int i=bd.size()-1; i>=0; --i) {
			if ( ! count(bd[i].begin(), bd[i].end(), 0)) {
				bd.erase(bd.begin()+i);
				N -= 5;
			}
		}
	}
};

int main() {
	int n, d, p, q;
	while (cin >> n, n) {
		TETORIS tet;
		for (int i=0; i<n; ++i) {
			cin >> d >> p >> q;
			if (d == 1) {
				tet.put(p, q-1);
				tet.update();
			} else {
				for (int j=0; j<p; ++j) tet.put(1, q-1);
				tet.update();
			}
		}
		cout << tet.N << endl;
	}
	return 0;
}

C++: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;

//// < "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\b.txt"

int fall(vector<vector<int>>&field, vector<vector<int>>&pino,int l) {
	{

	}
	int y = 0;
	for ( y = 0; y < field.size() - pino.size(); ++y) {
		bool ok = true;
		for (int i = 0; i < pino.size(); ++i) {
			for (int j = 0; j < pino[i].size(); ++j) {
				if (pino[i][j]) {
					if (field[y + i+1][l + j])ok = false;
				}
			}
		}
		if (!ok) {
			break;
		}
	}
	for (int i = 0; i < pino.size(); ++i) {
		for (int j = 0; j < pino[i].size(); ++j) {
			if (pino[i][j]) {
				assert(!field[y + i][l + j]);
				field[y + i][l + j] = true;
			}
		}
	}
	int delline = 0;
	for (int i = y + pino.size() - 1; i >= y; --i) {
		while (all_of(field[i].begin(), field[i].end(), [](const int a) {return a == 1; })) {
			transform(field[i].begin(), field[i].end(), field[i].begin(), [](const int a) {return false; });
			for (int j = i- 1; j >= 0; --j) {
				swap(field[j], field[j + 1]);
			}
			delline += 1;
		}
	}
	return delline;
}

int main() {
	while (1) {
		int N; cin >> N;
		if (!N)break;
		int sum = 0;
		vector<vector<int>>field(5*N+10, vector<int>(5));
		for (int i = 0; i < N; ++i) {
			int d, p, q; cin >> d >> p >> q; q--;
			int w = d == 2 ? 1 : p;
			int h = d == 1 ? 1 : p;
			sum += p;
			vector<vector<int>>pino(h, vector<int>(w, 1));
			sum -= fall(field, pino, q) * 5;
		}
		cout << sum << endl;
	}
	
	return 0;
}

C++: #include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int x[10000][5], m[5], maxn, sum;
int n;
int a, b, c;
int main() {
	while (true) {
		sum = 0;
		maxn = 0;
		memset(x, 0, sizeof(x));
		memset(m, 0, sizeof(m));
		cin >> n;
		if (n == 0) { break; }
		for (int h = 0; h < n; h++) {
			cin >> a >> b >> c;
			c--;
			if (a == 1) {
				maxn = 0;
				for (int j = c; j < c + b; j++) {
					maxn = max(maxn, m[j]);
				}
				for (int j = c; j < c + b; j++) {
					x[maxn][j] = 1;
					m[j] = maxn + 1;
				}
			}
			else {
				for (int j = 0; j < b; j++) {
					x[m[c] + j][c] = 1;
				}
				m[c] += b;
			}
			for (int i = 0; i < 10000; i++) {
				if (x[i][0] + x[i][1] + x[i][2] + x[i][3] + x[i][4] == 5) {
					x[i][0] = 0; x[i][1] = 0; x[i][2] = 0; x[i][3] = 0; x[i][4] = 0;
					for (int j = i; j < 9999; j++) {
						for (int k = 0; k < 5; k++) {
							x[j][k] = x[j + 1][k];
						}
					}
					x[9999][0] = 0; x[9999][1] = 0; x[9999][2] = 0; x[9999][3] = 0; x[9999][4] = 0;
					i--;
					m[0]--; m[1]--; m[2]--; m[3]--; m[4]--;
				}
			}
		}
		for (int i = 0; i < 10000; i++) {
			for (int j = 0; j < 5; j++) {
				sum += x[i][j];
			}
		}
		cout << sum << endl;
	}
}