[[AlgorithmQuiz/LcdDisplay]] [[C++]]로 작성 --[[destine]], 2004-09-21

runMain 부분은 정말 끔찍하네요 --;;

{{{#!cplusplus
// LcdPlay.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>

using namespace std;
#define _X(x) (x+2)
#define _Y(y) (2*y+3)
#define _SIZE(n) ((_X(n))*(_Y(n)))

class number{
protected:
	typedef enum FLAG{ T, TL, TR, M, BL, BR, B, E };
	int flags[7];
	
protected:
	number()
	{
		memset(flags,0,sizeof(flags));
	}
	void set(FLAG x)
	{
		flags[x] = 1;
	}
	int get(FLAG x)
	{
		if ( x == number::FLAG::E )
			return 0;
		return flags[x];
	}
	static FLAG status(int x, int y, int nSize)
	{
		if ( x == 0 )
		{
			if ( y != 0 && y < (_Y(nSize) - 1 )/2 )
				return number::FLAG::TL;
			else if ( y != _Y(nSize) - 1 && y > (_Y(nSize) - 1 )/2 )
				return number::FLAG::BL;
		}
		else if ( x == _X(nSize) - 1 )
		{
			if ( y != 0 && y < (_Y(nSize) - 1 )/2 )
				return number::FLAG::TR;
			else if ( y != _Y(nSize) - 1 && y > (_Y(nSize) - 1 )/2 )
				return number::FLAG::BR;
		}
		else 
		{
			if ( y == 0 )
				return number::FLAG::T;
			else if ( y == (_Y(nSize) - 1 )/2 )
				return number::FLAG::M;
			else if ( y == _Y(nSize) - 1 )
				return number::FLAG::B;
		}
		return number::FLAG::E;	
	}
	char getChar(FLAG x)
	{
		switch( x )
		{
		case number::FLAG::T:
		case number::FLAG::M:
		case number::FLAG::B:
			return '_';
			break;
		case number::FLAG::E:
			return ' ';
		default:
			return '|';
		}
		return ' ';
	}
public:
	void lcd(int nSize, char* buf)
	{
		int nIndex;
		for ( int x = 0; x < _X(nSize); x++ )
		{
			for ( int y = 0; y < _Y(nSize); y++ )
			{
				nIndex = y * _X(nSize) + x;
				buf[nIndex] = ' ';
				if ( get(status(x,y,nSize)) == 1 )
				{
					buf[nIndex] = getChar(status(x,y,nSize));
				}
			}
		}
	}
};

class one:public number{
public:
	one()
	{
		set(TL);
		set(BL);
	}
};
class two:public number{
public:
	two()
	{
		set(T);
		set(TR);
		set(M);
		set(BL);
		set(B);
	}
};
class three:public number{
public:
	three()
	{
		set(T);
		set(TR);
		set(M);
		set(BR);
		set(B);
	}
};
class four:public number{
public:
	four()
	{
		set(TL);
		set(TR);
		set(M);
		set(BR);
	}
};
class five:public number{
public:
	five()
	{
		set(T);
		set(TL);
		set(M);
		set(BR);
		set(B);
	}
};
class six:public number{
public:
	six()
	{
		set(T);
		set(TL);
		set(M);
		set(BL);
		set(BR);
		set(B);
	}
};
class seven:public number{
public:
	seven()
	{
		set(T);
		set(TR);
		set(BR);
	}
};
class eight:public number{
public:
	eight()
	{
		set(T);
		set(TL);
		set(TR);
		set(M);
		set(BL);
		set(BR);
		set(B);
	}
};
class nine:public number{
public:
	nine()
	{
		set(T);
		set(TL);
		set(TR);
		set(M);
		set(BR);
		set(B);
	}
};
class zero:public number{
public:
	zero()
	{
		set(T);
		set(TL);
		set(TR);
		set(BL);
		set(BR);
		set(B);
	}
};

class numberFac{
	static one a1;
	static two a2;
	static three a3;
	static four a4;
	static five a5;
	static six a6;
	static seven a7;
	static eight a8;
	static nine a9;
	static zero a0;
public:
	static number getInstance(int nNumber)
	{
		switch(nNumber)
		{
		case 1:
			return a1;
		case 2:
			return a2;
		case 3:
			return a3;
		case 4:
			return a4;
		case 5:
			return a5;
		case 6:
			return a6;
		case 7:
			return a7;
		case 8:
			return a8;
		case 9:
			return a9;
		case 0:
			return a0;
		}
		return a0;
	}
};

one numberFac::a1;
two numberFac::a2;
three numberFac::a3;
four numberFac::a4;
five numberFac::a5;
six numberFac::a6;
seven numberFac::a7;
eight numberFac::a8;
nine numberFac::a9;
zero numberFac::a0;

bool assert( int x, int y )
{
	if ( x == y )
	{
		cout<<"assert equal\n";
		return true;
	}
	else 
	{
		cout<<"assert not equal\n";
		return false;
	}
}

bool assert(char* x, char* y )
{
	bool bRet = true;
	
	if ( sizeof(x) != sizeof(y) )
	{
		bRet = false;
	}
	else
	{
		for ( int i = 0; i < sizeof(x); i ++ )
		{
			if ( x[i] != y[i] )
			{
				bRet = false;
				break;
			}
		}
	}
	
	assert( true, bRet );
	return bRet;
}
bool input( int& nSize, int& nNumber )
{
	cin>>nSize;
	
	if ( nSize == 0 )
		return false;
	
	cin>>nNumber;
	
	return true;
}

bool LcdNumber(int nSize, int nNumber, char* buf)
{
	number num = numberFac::getInstance(nNumber);
	num.lcd( nSize, buf );
	return true;
}

void test2_4()
{
	char buf[_SIZE(2)];
	char* szResult = 
		"    "
		"|  |"
		"|  |"
		" __ "
		"   |"
		"   |"
		"    ";
	LcdNumber(2,4,buf);
	
	assert(buf, szResult);
}

void test1_4()
{
	char buf[_SIZE(1)];
	char* szResult = 
		"   "
		"| |"
		" _ "
		"  |"
		"   ";
	
	LcdNumber(1,4,buf);
	
	assert(buf, szResult);
}

void test1_3()
{
	char buf[_SIZE(1)];
	char* szResult = 
		" _ "
		"  |"
		" _ "
		"  |"
		" _ ";
	
	LcdNumber(1,2,buf);
	
	assert(buf, szResult);
}

void test1_2()
{
	char buf[_SIZE(1)];
	char* szResult = 
		" _ "
		"  |"
		" _ "
		"|  "
		" _ ";
	
	LcdNumber(1,2,buf);
	
	assert(buf, szResult);
}

void test1_1()
{
	char buf[_SIZE(1)];
	char* szResult = 
		"   "
		"|  "
		"   "
		"|  "
		"   ";
	
	LcdNumber(1,1,buf);
	
	assert(buf, szResult);
}

void testMain()
{
	assert( " |", " | ");
	assert( " | ", " | ");
	assert( _X(1), 3 );
	assert( _Y(1), 5 );
	assert( _SIZE(1), (1+2)*(2*1+3) );
	test1_1();
	test1_2();
	test1_3();
	test1_4();
	test2_4();
}

void print(int nSize, char* pBuffer)
{
	for( int j = 0; j < _Y(nSize); j++ )
	{
		for( int i = 0; i < _X(nSize); i ++ )
		{
			cout<<pBuffer[(j*_X(nSize))+i];
		}
		cout<<"\n";
	}
}

void runMain()
{
	int nSize;
	int nNumber;
	while( true )
	{
		cin>>nSize;
		if ( nSize <= 0 )
			return;
		cin>>nNumber;
		if ( nNumber < 0 )
			return;
		
		if ( nNumber == 0 )
		{
			char* pBuffer = new char[_SIZE(nSize)];
			LcdNumber( nSize, nNumber, pBuffer );
			print( nSize, pBuffer );
			delete[] pBuffer;
			continue;
		}
		
		for( int i = 1; true; i *= 10 )
		{
			if ( nNumber / i == 0 )
			{
				int tempNum = nNumber;
				char* pBuffer = new char[_SIZE(nSize)];
				for( int j = i/10; j >= 1 ; j /= 10 )
				{
					LcdNumber( nSize, tempNum / j, pBuffer );
					print( nSize, pBuffer );
					tempNum -= ((tempNum / j) * j);
				}
				delete[] pBuffer;
				break;
			}
		}
	}
}

int main(int argc, char* argv[])
{
	char szPause;
	//      testMain();
	runMain();
	cin>>szPause;
	return 0;
}
}}}