# Fun fact
Tetris was the first video game played in outer space

In 1993, Russian cosmonaut Aleksandr A. Serebrov spent 196 days on the Mir space station with a very special distraction: a gray Game Boy loaded with Tetris. During that time the game orbited the Earth 3,000 times and became the first video game played in space. The Game Boy was sold in a Bonhams auction for $1,220 during the Space History Sale in 2011.

# Task
Parse the game log and determine how many lines have been cleared through the game. The game ends if all commands from input were interpreted or the maximum field height (30 units) is reached.

A horizontal line, according to the rules of classic Tetris, is considered cleared if it represents a solid line without gaps formed by falling blocks.
When such a line is formed, it disappears and any blocks above it fall down to fill the space.

# Input
```python
['4L2', '3R4', '4L3', '3L4', '4R0', '1L2'] # example
```
As an argument, you are given gamelog - an array of commands which you need to interpret.

Each command has the same form:
* The first character - the type of block (integer from 1 to 4, as in this kata we have only 4 types of blocks). Block types are described below.
* The second - the direction of movement (`"R"` or `"L"` - right or left).
* The third is an offset (integer from 0 to 4, as width of our field 9 units and new block always appears at the center of the field) relative to the starting position. Thus, `L4` means the leftmost position, and `R4` the rightmost, and `L0` is equivalent to `R0`.

# Output
The total number of cleaned horizontal lines (`int`) to the end of the game. Note, if the field height is exceeded, then the game ends immediately.

# Blocks
In this kata we have only 4 types of blocks. Yes, this is not a classic set of shapes, but this is only for simplicity.
```
# and their graphical representation:
             ■
         ■   ■
     ■   ■   ■
 ■   ■   ■   ■
---+---+---+---
#1  #2  #3  #4
```
# Field
Gamefield (a rectangular vertical shaft) has width 9 units and height 30 units.


table, th, td {
  border: 1px solid;
}


Indices can be represented as:


L4
L3
L2
L1
L0/R0
R1
R2
R3
R4



# Example 1
```python
>>> gamelog = ['1R4', '2L3', '3L2', '4L1', '1L0', '2R1', '3R2', '4R3', '1L4']
>>> tetris(gamelog)
1
```
Gamefield before last command (_ means empty space):
```
___■___■_
__■■__■■_
_■■■_■■■_
_■■■■■■■■
```
Gamefield after all commands:
```
___■___■_
__■■__■■_
_■■■_■■■_
```
As you can see, one solid line was cleared. So, answer is 1.

# Example 2
```python
>>> gamelog = ['1L2', '4R2', '3L3', '3L1', '1L4', '1R4']
>>> tetris(gamelog)
0
```
Gamefield after all commands:
```
 _____■__
_■_■__■__
_■_■__■__
■■■■__■_■
```
As you can see, there is no solid lines, so nothing to clear. Our answer is 0, zero cleaned lines.

# Note

Since there is no rotation of blocks in our model and all blocks are very simple, do not overthink the task.

# Other  

If you like the idea: leave feedback, and there will be more katas in the Tetris series.

* 7 kyuTetris Series #1 — Scoring System
* 6 kyuTetris Series #2 — Primitive Gameplay
* 6 kyuTetris Series #3 — Adding Rotation (TBA)
* 5 kyuTetris Series #4 — New Block Types (TBA)
* 4 kyuTetris Series #5 — Complex Block Types (TBA?)

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Data structures

Game theory

Starter code: def tetris(arr):
	

Solutions:
pos = {'L4': 0, 'L3': 1, 'L2': 2, 'L1': 3, 'L0': 4, 'R0': 4, 'R1': 5, 'R2': 6, 'R3': 7, 'R4': 8}

def tetris(arr):
	(current, res) = ([0] * 9, 0)
	for x in arr:
		p = pos[x[1:]]
		current[p] += int(x[0])
		if current[p] >= 30:
			break
		y = min(current)
		if y:
			(current, res) = ([v - y for v in current], res + y)
	return res


class Game:

	def __init__(self, arr):
		self.comands = arr
		self.score = 0
		self.step = None
		self.fild = [-1] * 9
		self.over = lambda x: max(x) >= 29

	def __break__(self):
		while -1 not in self.fild:
			self.score += 1
			self.fild = [e - 1 for e in self.fild]
		return self.over(self.fild)

	def __values__(self, comand):
		self.step = 4 + {'R': lambda m: +int(m), 'L': lambda m: -int(m)}[comand[1]](comand[2])
		return int(comand[0])

	def game(self):
		for comand in self.comands:
			block = self.__values__(comand)
			self.fild[self.step] += block
			if self.__break__():
				break
		return self.score

def tetris(arr) -> int:
	play = Game(arr)
	return play.game()


def tetris(arr) -> int:
	(bd, lines) = ([0] * 9, 0)
	for (n, d, m) in arr:
		i = int(m) * (-1) ** (d == 'R')
		bd[i] += int(n)
		if bd[i] > 29:
			h = min(bd)
			if bd[i] - h > 29:
				break
			lines += h
			bd = [v - h for v in bd]
	lines += min(bd)
	return lines


from collections import Counter

def tetris(arr):
	fields = Counter()
	clear = 0
	for log in arr:
		pos = log[1:].replace('R0', 'L0')
		fields[pos] += int(log[0])
		if fields[pos] >= 30:
			break
		elif len(fields) == 9:
			c = min(fields.values())
			clear += c
			for pos in fields:
				fields[pos] -= c
	return clear


def tetris(arr) -> int:
	lines_cleared = 0
	sum = [0, 0, 0, 0, 0, 0, 0, 0, 0]
	dict = {'L4': 0, 'L3': 1, 'L2': 2, 'L1': 3, 'L0': 4, 'R0': 4, 'R1': 5, 'R2': 6, 'R3': 7, 'R4': 8}
	for i in arr:
		sum[dict[i[-2:]]] += int(i[0])
		lines = min(sum)
		sum = [i - lines for i in sum]
		lines_cleared += lines
		if max(sum) >= 30:
			break
	return lines_cleared


import numpy as np
col_dict = {'L4': 0, 'L3': 1, 'L2': 2, 'L1': 3, 'L0': 4, 'R0': 4, 'R1': 5, 'R2': 6, 'R3': 7, 'R4': 8}

def tetris(arr) -> int:
	field = np.zeros(9, dtype=np.int8)
	counter = 0
	for turn in arr:
		block_height = int(turn[0])
		index = col_dict[turn[1:]]
		field[index] += block_height
		if field[index] >= 30:
			return counter
		else:
			counter += field.min()
			field -= field.min()
	return counter


def tetris(lst):
	(field, lines) = ([0] * 9, 0)
	for (h, s, m) in lst:
		i = 4 + int(m) * (-1 if s == 'L' else 1)
		field[i] += int(h)
		while all((col > 0 for col in field)):
			(field, lines) = ([col - 1 for col in field], lines + 1)
		if field[i] > 29:
			break
	return lines


def tetris(a):
	(b, glob_min) = ([0] * 9, 29)
	for (x, y, z) in a:
		i = int(z) * (-1) ** (y == 'R')
		b[i] += int(x)
		if b[i] > glob_min:
			n = min(b)
			if b[i] - n > 29:
				return n
			glob_min = n + 29
	return min(b)


import numpy as np

def columnDecode(code):
	code = code.replace('R', '+')
	code = code.replace('L', '-')
	return int(code) + 4

def placePiece(colList, size, i):
	for x in range(i, size + i):
		colList[x] = 1
	return colList

def lineCheck(board):
	i = 0
	for i in range(5):
		if not all(board[:, i]):
			break
	return i

def tetris(arr):
	totalLines = 0
	board = np.zeros((9, 29), dtype='int')
	for piece in arr:
		col = columnDecode(piece[1:])
		size = int(piece[0])
		for i in range(len(board[col]) - 1, -1, -1):
			if board[col][i - 1] == 1 or i <= 0:
				try:
					board[col] = placePiece(board[col], size, i)
				except:
					return totalLines
				lines = lineCheck(board)
				if lines > 0:
					board = board[:, lines:]
					board = np.hstack((board, np.zeros((board.shape[0], lines), dtype='int')))
					totalLines += lines
					lines = 0
				break
	return totalLines


def tetris(arr):
	(d, c) = ({}, 0)
	for (i, j) in enumerate(arr):
		(t, dt) = (j[1:].replace('R0', 'L0'), d.values())
		d[t] = d.get(t, 0) + int(j[0])
		if len(dt) == 9 and all(dt):
			m = min(d.values())
			d = {k: l - m for (k, l) in d.items()}
			c += m
		if d[t] >= 30:
			break
	return c