二値画像の回転


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

void Kaiten::storagePictureSize(const char& input)
{
	m_pictureSize = (int)(input - '0');
}

std::string Kaiten::changeHexToBit(const char& hexCharData)
{
	std::string result = "";
	int hexData;

	iswdigit(hexCharData) ? hexData = (int)(hexCharData - '0') : hexData = (int)(hexCharData - 'a' + 10);

	for(int i=4; 0<i; i--){
		if(pow(2,i-1) <= hexData){
			result += "*";
			hexData -= pow(2,i-1);
		}else{
			result += "-";
		}
	}
	return result;
}

std::string Kaiten::changeBitToHex(std::string turnHexData)
{
	std::string result = "";

	for(int i=0; i<turnHexData.size(); i +=4){
		int hexData = 0;
		for(int j=0; j<4 && i+j<turnHexData.size(); j++){
			if(turnHexData.at(i+j) == '*')
				hexData += pow(2,3-j);
		}
		hexData < 10 ? result += std::to_string(hexData) : result += hexData -10 + 'a';
		hexData = 0;
	}
	return result;
}

std::string Kaiten::getPictureBitDatas(const std::string& input)
{
	std::string hexDataString = input.substr(2);
	std::string result = "";
	for(int i=0; i<hexDataString.size(); i++){
		result += changeHexToBit(hexDataString.at(i));
	}
	return result;
}

std::string Kaiten::makeTurnPicture(const std::string& hexData, char** picture, char** turnPicture)
{
	std::string hexStr = "";

	for(int i=0; i<m_pictureSize; i++){
		for(int j=0; j<m_pictureSize; j++){
			picture[i][j] = hexData.at(i*m_pictureSize+j);
		}
	}

	for(int i=0; i<m_pictureSize; i++){
		for(int j=0; j<m_pictureSize; j++){
			turnPicture[i][j] = picture[m_pictureSize-1-j][i];
		}
	}

	for(int i=0; i<m_pictureSize; i++){
		for(int j=0; j<m_pictureSize; j++){
			hexStr += turnPicture[i][j];
		}
	}

	return hexStr;
}

const std::string Kaiten::solve(const std::string& input)
{
	storagePictureSize(input.at(0));
	char** picture = new char*[m_pictureSize];
	char** turnPicture = new char*[m_pictureSize];

	for( int i=0; i<m_pictureSize; i++ ) {
	    picture[i] = new char[m_pictureSize];
	    turnPicture[i] = new char[m_pictureSize];
	}

	std::string hexData	= getPictureBitDatas(input);
	std::string turnHexData = makeTurnPicture(hexData, picture, turnPicture);
	std::string result = changeBitToHex(turnHexData);

	return input.substr(0,2) + result;
}

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

int main()
{
	Kaiten kaiten;
	kaiten.test("3:5b8", "3:de0");
	kaiten.test("1:8", "1:8");
	kaiten.test("2:8", "2:4");
	kaiten.test("2:4", "2:1");
	kaiten.test("2:1", "2:2");
	kaiten.test("3:5d0", "3:5d0");
	kaiten.test("4:1234", "4:0865");
	kaiten.test("5:22a2a20", "5:22a2a20");
	kaiten.test("5:1234567", "5:25b0540");
	kaiten.test("6:123456789", "6:09cc196a6");
	kaiten.test("7:123456789abcd", "7:f1a206734b258");
	kaiten.test("7:fffffffffffff", "7:ffffffffffff8");
	kaiten.test("7:fdfbf7efdfbf0", "7:ffffffffffc00");
	kaiten.test("8:123456789abcdef1", "8:f0ccaaff78665580");
	kaiten.test("9:112233445566778899aab", "9:b23da9011d22daf005d40");

	return 0;
};

```

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

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

class Kaiten
{
public:
	void test(const std::string& input, const std::string& output);
private:
	const std::string solve(const std::string& input);
	void storagePictureSize(const char& input);
	std::string getPictureBitDatas(const std::string& input);
	std::string changeHexToBit(const char& hexCharData);
	std::string changeBitToHex(std::string turnHexData);
	std::string makeTurnPicture(const std::string& hexData, char** picture, char** turnPicture);
	unsigned int m_pictureSize;
};

#endif
```