テトロミノ認識

```Source.cpp
#include "Header.h"

Tetromino::Tetromino()
{
	m_allDirections = 0;
	m_diagonally = 0;
	m_fourMass = 0;
	m_keimatobi = 0;
	m_same = 0;
}

int Tetromino::countAllDirectionsBlacks(const int& diff)
{
	switch(diff){
		case 1:
		case 10: return 1;
		default: return 0;
	}
}

int Tetromino::countDiagonallyBlacks(const int& diff)
{
	switch(diff){
		case 9:
		case 11: return 1;
		default: return 0;
	}
}

int Tetromino::countFourMassBlacks(const int& diff)
{
	switch(diff){
		case 3:
		case 30: return 1;
		default: return 0;
	}
}

int Tetromino::countKeimatobiBlacks(const int& diff)
{
	switch(diff){
		case 8:
		case 12:
		case 19:
		case 21: return 1;
		default: return 0;
	}
}

int Tetromino::countSameBlacks(const int& diff)
{
	if(diff == 0){
		return 1;
	}
	return 0;
}

bool Tetromino::isTetromino(const int& allDirections, const int& diagonally, const int& fourMass, const int& keimatobi)
{
	if(m_allDirections != allDirections)
		return false;
	if(m_diagonally != diagonally)
		return false;
	if(m_fourMass != fourMass)
		return false;
	if(m_keimatobi != keimatobi)
		return false;
	return true;
}

const std::string Tetromino::checkTetrominos()
{
	if(BLOCKDATA < m_same)
		return "-";
	if(isTetromino(6, 2, 0, 2))
		return "L";
	if(isTetromino(6, 0, 2, 0))
		return "I";
	if(isTetromino(6, 4, 0, 0))
		return "T";
	if(isTetromino(8, 4, 0, 0))
		return "O";
	if(isTetromino(6, 4, 0, 2))
		return "S";
	return "-";
}

void Tetromino::setTetrominos(const std::string& input)
{
	for(int index=0; index<BLOCKDATA; index++){
		std::string tetoriMino = input.substr(index*3, 2);
		m_filds[index] = (int)(tetoriMino.at(0) - '0') * 10 + (int)(tetoriMino.at(1) - '0');
	}
}

const std::string Tetromino::solve(const std::string& input)
{
	setTetrominos(input);
 	for(int i=0; i<BLOCKDATA; i++){
		for(int j=0; j<BLOCKDATA; j++){
			int diff = abs(m_filds[i] - m_filds[j]);
			m_allDirections += countAllDirectionsBlacks(diff);
			m_diagonally += countDiagonallyBlacks(diff);
			m_fourMass += countFourMassBlacks(diff);
			m_keimatobi += countKeimatobiBlacks(diff);
			m_same += countSameBlacks(diff);
		}
	}

	std::string result = checkTetrominos();
	return result;
}

void test(const std::string& input, const std::string& output)
{
	Tetromino tm;
	const std::string result = tm.solve(input);
	if(result == output){
		std::cout << "test is OK" << std::endl;
	}else{
		std::cout << "test is NG" << std::endl;
	}
}

int main()
{
  /*#1*/ test("55,55,55,55", "-");
  /*#2*/ test("39,28,27,29", "L");
  /*#3*/ test("63,62,43,53", "L");
  /*#4*/ test("32,42,43,44", "L");
  /*#5*/ test("81,72,91,71", "L");
  /*#6*/ test("62,64,72,63", "L");
  /*#7*/ test("45,25,35,24", "L");
  /*#8*/ test("12,20,22,21", "L");
  /*#9*/ test("66,46,67,56", "L");
  /*#10*/ test("44,46,45,43", "I");
  /*#11*/ test("04,24,14,34", "I");
  /*#12*/ test("43,42,41,40", "I");
  /*#13*/ test("48,38,58,68", "I");
  /*#14*/ test("31,20,22,21", "T");
  /*#15*/ test("69,79,78,89", "T");
  /*#16*/ test("42,33,44,43", "T");
  /*#17*/ test("16,25,05,15", "T");
  /*#18*/ test("27,37,28,38", "O");
  /*#19*/ test("13,24,23,14", "O");
  /*#20*/ test("63,72,62,73", "O");
  /*#21*/ test("73,63,62,74", "S");
  /*#22*/ test("56,57,47,66", "S");
  /*#23*/ test("88,99,98,87", "S");
  /*#24*/ test("62,43,52,53", "S");
  /*#25*/ test("86,95,87,96", "S");
  /*#26*/ test("84,83,73,94", "S");
  /*#27*/ test("32,33,41,42", "S");
  /*#28*/ test("86,85,75,96", "S");
  /*#29*/ test("97,76,96,77", "-");
  /*#30*/ test("53,55,45,43", "-");
  /*#31*/ test("73,93,94,84", "-");
  /*#32*/ test("31,33,41,42", "-");
  /*#33*/ test("21,32,11,12", "-");
  /*#34*/ test("73,75,65,64", "-");
  /*#35*/ test("64,65,45,54", "-");
  /*#36*/ test("12,00,01,10", "-");
  /*#37*/ test("94,85,75,74", "-");
  /*#38*/ test("87,86,77,75", "-");
  /*#39*/ test("56,56,56,56", "-");
  /*#40*/ test("41,42,41,52", "-");
  /*#41*/ test("61,60,63,61", "-");
  /*#42*/ test("03,13,33,13", "-");
  /*#43*/ test("92,96,94,93", "-");
  /*#44*/ test("15,25,55,45", "-");
  /*#45*/ test("17,14,16,13", "-");
  /*#46*/ test("72,83,83,92", "-");
  /*#47*/ test("40,40,42,51", "-");
  /*#48*/ test("81,80,93,82", "-");
  /*#49*/ test("51,61,30,41", "-");
  /*#50*/ test("17,37,35,15", "-");
	return 0;
}

```

```Header.h
#ifndef _HEADER_H
#define _HEADER_H

#include <string>
#include <iostream>
#include <math.h>

#define BLOCKDATA 4
#define FILDSIZE 10

void test(const std::string& input, const std::string& output);

class Tetromino
{
public:
	Tetromino();
	const std::string solve(const std::string& input);

private:
	void setTetrominos(const std::string& input);
	const std::string checkTetrominos();
	int countAllDirectionsBlacks(const int& diff);
	int countDiagonallyBlacks(const int& diff);
	int countFourMassBlacks(const int& diff);
	int countKeimatobiBlacks(const int& diff);
	int countSameBlacks(const int& diff);
	bool isTetromino(const int& allDirections, const int& diagonally, const int& fourMass, const int& keimatobi);

	int m_filds[BLOCKDATA];
	int m_allDirections;
	int m_diagonally;
	int m_fourMass;
	int m_keimatobi;
	int m_same;
};

#endif
```