모든 체스 말을 기준으로 계산해도 되고 검정, 흰 King을 중심으로 이 녀석이 공격을 받는지 검사해도 된다. 난 King을 중심으로 공격을 받는지를 검사했다.

좀 더 다듬으면 Queen, Rook, Bishop을 검사할 때 중복되는 부분을 제거할 수 있다. 더 다듬고 줄이니 코드가 더 읽기 힘들어져서 이 정도로 마무리.

유닛 테스트하다가 올릴 뻔했다. 조낸 귀찮음. 저렇게까지 테스트할 필요가 있을까? 아니다. 크롬 소스를 보니 저거보다 더 심하더라. 이건 아직 계속 경험해보는 게 좋은 단계라서 뭐라 하기 힘들다.

소스 코드

////////////////////////////////////////////////////////////////////////////////
// UVa Online Judge(http://uva.onlinejudge.org/)
//
// problem : 10196 Check The Check
//           (http://uva.onlinejudge.org/external/101/10196.html)
//
// - OOP, Unit test, STL을 남발한다.
// - 속도보다는 읽기 좋게 작성한다.
//
// This file is licenced under a Creative Commons license:
// http://creativecommons.org/licenses/by-nc-sa/2.0/kr/
////////////////////////////////////////////2010. 04. 07 ohyecloudy at gmail.com
//////////////////////////////////////////////////////http://ohyecloudy.com/algo

#ifdef ONLINE_JUDGE
#   define UNIT_TEST 0
#else
#   define UNIT_TEST 1
#endif 

#if UNIT_TEST
#    include <gtest/gtest.h>
#    include <sstream>
#endif

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

//#############################################################################V
// submit code

////////////////////////////////////////////////////////////////////////////////
struct PieceColor
{
	enum Type
	{
		BLACK,
		WHITE,
	};
};

struct Piece
{
	enum Type
	{
	    EMPTY			= '.',
		INVALID			= '#',

		BLACK_PAWN		= 'p',
		BLACK_ROOK		= 'r',
		BLACK_BISHOP	= 'b',
		BLACK_QUEEN		= 'q',
		BLACK_KING		= 'k',
		BLACK_KNIGHT	= 'n',

		WHITE_PAWN		= 'P',
		WHITE_ROOK		= 'R',
		WHITE_BISHOP	= 'B',
		WHITE_QUEEN		= 'Q',
		WHITE_KING		= 'K',
		WHITE_KNIGHT	= 'N',
	};
};

////////////////////////////////////////////////////////////////////////////////
class ChessBoard
{
public:
    //--------------------------------------------------------------------------
    ChessBoard()
    {
        m_configuration.resize(BOARD_EXTENT);
        for (Configuration::iterator iter = m_configuration.begin();
            iter != m_configuration.end(); ++iter)
        {
            iter->resize(BOARD_EXTENT);
        }

        ClearBoard();
    }

    //--------------------------------------------------------------------------
    void        Load(std::istream& ist)
    {
        ClearBoard();

        char input;
        for (int i = 0; i < BOARD_EXTENT; ++i)
        {
            for (int j = 0; j < BOARD_EXTENT; ++j)
            {
                ist >> input;
				m_configuration[j][i] = static_cast<Piece::Type>(input);
                TestAndUpdateKing(j, i);
            }
        }
    }

    //--------------------------------------------------------------------------
    std::string    CheckTheCheck()
    {
        std::string colorInCheck = "no";

        // there won't be a configuration where both kings are in check.
        if (IsInCheck(m_whiteKing.first, m_whiteKing.second, PieceColor::BLACK))
        {
            colorInCheck = "white";
        }
        else if (
			IsInCheck(m_blackKing.first, m_blackKing.second, PieceColor::WHITE))
        {
            colorInCheck = "black";
        }

        return colorInCheck + " king is in check.";
    }

    //--------------------------------------------------------------------------
    bool        IsInCheck(int x, int y, PieceColor::Type attack) const
    {
        return
            IsPawnAttack(x, y, attack) ||
            IsRookAttack(x, y, attack) ||
            IsBishopAttack(x, y, attack) ||
            IsQueenAttack(x, y, attack) ||
            IsKnightAttack(x, y, attack);
    }

    //--------------------------------------------------------------------------
    bool        ExistBothKings() const
    {
        return
            m_blackKing.first != INVALID_COORD &&
			m_blackKing.second != INVALID_COORD &&
            m_whiteKing.first != INVALID_COORD &&
			m_whiteKing.second != INVALID_COORD;
    }

    //--------------------------------------------------------------------------
	void        PlacePiece(int x, int y, Piece::Type piece)
    {
        m_configuration[x][y] = piece;
        TestAndUpdateKing(x, y);
    }

    //--------------------------------------------------------------------------
    void        ClearBoard()
    {
        m_blackKing = Coord(INVALID_COORD, INVALID_COORD);
        m_whiteKing = Coord(INVALID_COORD, INVALID_COORD);

        for( Configuration::iterator iter = m_configuration.begin();
            iter != m_configuration.end(); ++iter )
        {
            ConfigurationCol& col = *iter;
            std::fill(col.begin(), col.end(), Piece::EMPTY);
        }
    }

    //--------------------------------------------------------------------------
    bool        IsPawnAttack(int x, int y, PieceColor::Type attack) const
    {
        if (attack == PieceColor::BLACK)
        {
            if (Piece::BLACK_PAWN == GetPiece( x+1, y-1 ) ||
                Piece::BLACK_PAWN == GetPiece( x-1, y-1 ))
            {
                return true;
            }
        }
        else
        {
            if (Piece::WHITE_PAWN == GetPiece( x+1, y+1 ) ||
                Piece::WHITE_PAWN == GetPiece( x-1, y+1 ))
            {
                return true;
            }
        }

        return false;
    }

    //--------------------------------------------------------------------------
    bool        IsRookAttack(int x, int y, PieceColor::Type attack) const
    {
        char piece = Piece::BLACK_ROOK;
        if (attack == PieceColor::WHITE)
        {
            piece = Piece::WHITE_ROOK;
        }

        if (piece == GetFirstPiece( x, y,  0, -1 ))        return true;
        if (piece == GetFirstPiece( x, y,  0,  1 ))        return true;
        if (piece == GetFirstPiece( x, y, -1,  0 ))        return true;
        if (piece == GetFirstPiece( x, y,  1,  0 ))        return true;

        return false;
    }

    //--------------------------------------------------------------------------
    bool        IsBishopAttack(int x, int y, PieceColor::Type attack) const
    {
        char piece = Piece::BLACK_BISHOP;
        if (attack == PieceColor::WHITE)
        {
            piece = Piece::WHITE_BISHOP;
        }

        if (piece == GetFirstPiece( x, y, -1, -1 ))        return true;
        if (piece == GetFirstPiece( x, y,  1, -1 ))        return true;
        if (piece == GetFirstPiece( x, y, -1,  1 ))        return true;
        if (piece == GetFirstPiece( x, y,  1,  1 ))        return true;

        return false;
    }

    //--------------------------------------------------------------------------
    bool        IsQueenAttack(int x, int y, PieceColor::Type attack) const
    {
        char piece = Piece::BLACK_QUEEN;
        if (attack == PieceColor::WHITE)
        {
            piece = Piece::WHITE_QUEEN;
        }

        if (piece == GetFirstPiece( x, y,  0, -1 ))        return true;
        if (piece == GetFirstPiece( x, y,  0,  1 ))        return true;
        if (piece == GetFirstPiece( x, y, -1,  0 ))        return true;
        if (piece == GetFirstPiece( x, y,  1,  0 ))        return true;
        if (piece == GetFirstPiece( x, y, -1, -1 ))        return true;
        if (piece == GetFirstPiece( x, y,  1, -1 ))        return true;
        if (piece == GetFirstPiece( x, y, -1,  1 ))        return true;
        if (piece == GetFirstPiece( x, y,  1,  1 ))        return true;

        return false;
    }

    //--------------------------------------------------------------------------
    bool        IsKnightAttack(int x, int y, PieceColor::Type attack) const
    {
        char piece = Piece::BLACK_KNIGHT;
        if (attack == PieceColor::WHITE)
        {
            piece = Piece::WHITE_KNIGHT;
        }

        if (piece == GetPiece( x-1,    y-2 ))            return true;
        if (piece == GetPiece( x+1,    y-2 ))            return true;
        if (piece == GetPiece( x-2,    y-1 ))            return true;
        if (piece == GetPiece( x+2,    y-1 ))            return true;
        if (piece == GetPiece( x-2,    y+1 ))            return true;
        if (piece == GetPiece( x+2,    y+1 ))            return true;
        if (piece == GetPiece( x-1,    y+2 ))            return true;
        if (piece == GetPiece( x+1,    y+2 ))            return true;

        return false;
    }

private:
    //--------------------------------------------------------------------------
	Piece::Type		GetPiece(int x, int y) const
    {
        if (x < 0 || x >= BOARD_EXTENT)    return Piece::INVALID;
        if (y < 0 || y >= BOARD_EXTENT)    return Piece::INVALID;

        return m_configuration[x][y];
    }

    //--------------------------------------------------------------------------
    const Piece::Type	GetFirstPiece(int startX, int startY, int dx, int dy) const
    {
        if (dx == 0 && dy == 0)            return GetPiece(startX, startY);

        int curX = startX + dx;
        int curY = startY + dy;

        Piece::Type current = Piece::INVALID;
        while ((current = GetPiece(curX, curY)) != Piece::INVALID)
        {
            if (current != Piece::EMPTY)
            {
                return current;
            }

            curX += dx;
            curY += dy;
        }

        return current;
    }

    //--------------------------------------------------------------------------
    void        TestAndUpdateKing(int x, int y)
    {
		if (Piece::WHITE_KING == m_configuration[x][y])
        {
            m_whiteKing.first = x;
            m_whiteKing.second = y;
        }
		else if (Piece::BLACK_KING == m_configuration[x][y])
        {
            m_blackKing.first = x;
            m_blackKing.second = y;
        }
    }

private:
	typedef std::vector<Piece::Type>         ConfigurationCol;
    typedef std::vector<ConfigurationCol>    Configuration;
    Configuration                            m_configuration;

    typedef std::pair<int, int>              Coord;
    Coord                                    m_blackKing;
    Coord                                    m_whiteKing;

	static const int INVALID_COORD;
    static const int BOARD_EXTENT;
};

const int ChessBoard::INVALID_COORD		= -1;
const int ChessBoard::BOARD_EXTENT		= 8;

//#############################################################################A

#if UNIT_TEST
//#############################################################################V
// test code
TEST( piece_attack, pawn )
{
    ChessBoard board;

    {
        //........
        //p.......
        //.*......
        board.ClearBoard();
        board.PlacePiece( 0, 1, Piece::BLACK_PAWN );
        ASSERT_TRUE( board.IsPawnAttack( 1, 2, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsPawnAttack( 2, 2, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsPawnAttack( 0, 1, PieceColor::BLACK ) );
    }

    {
        //.p......
        //*.*.....
        board.ClearBoard();
        board.PlacePiece( 1, 0, Piece::BLACK_PAWN );
        ASSERT_TRUE( board.IsPawnAttack( 0, 1, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsPawnAttack( 2, 1, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsPawnAttack( 1, 1, PieceColor::BLACK ) );
    }

    {
        //.......p
        //......*.
        board.ClearBoard();
        board.PlacePiece( 7, 0, Piece::BLACK_PAWN );
        ASSERT_TRUE( board.IsPawnAttack( 6, 1, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsPawnAttack( 7, 1, PieceColor::BLACK ) );
    }

    {
        //.*......
        //P.......
        board.ClearBoard();
        board.PlacePiece( 0, 1, Piece::WHITE_PAWN );
        ASSERT_TRUE( board.IsPawnAttack( 1, 0, PieceColor::WHITE ) );
        ASSERT_FALSE( board.IsPawnAttack( 0, 1, PieceColor::WHITE ) );
    }
}

TEST( piece_attack, rook )
{
    ChessBoard board;

    {
        //...*....
        //...*....
        //...*....
        //...*....
        //***r****
        //...*....
        //...*....
        //...*....

        board.ClearBoard();
        board.PlacePiece( 3, 4, Piece::BLACK_ROOK );
        ASSERT_TRUE( board.IsRookAttack( 3, 0, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 3, 1, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 3, 2, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 3, 3, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 3, 5, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 3, 6, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 3, 7, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 0, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 1, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 2, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 5, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 6, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsRookAttack( 7, 4, PieceColor::BLACK ) );

        ASSERT_FALSE( board.IsRookAttack( 3, 4, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsRookAttack( 0, 0, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsRookAttack( 7, 7, PieceColor::BLACK ) );
    }

    {
        //...*....
        //...p....
        //........
        //........
        //*p.r..p*
        //........
        //...p....
        //...*....

        board.ClearBoard();
        board.PlacePiece( 3, 4, Piece::BLACK_ROOK );
        board.PlacePiece( 3, 1, Piece::BLACK_PAWN );
        board.PlacePiece( 3, 6, Piece::BLACK_PAWN );
        board.PlacePiece( 1, 4, Piece::BLACK_PAWN );
        board.PlacePiece( 6, 4, Piece::BLACK_PAWN );
        ASSERT_FALSE( board.IsRookAttack( 3, 0, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsRookAttack( 3, 7, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsRookAttack( 0, 4, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsRookAttack( 0, 7, PieceColor::BLACK ) );
    }
}

TEST( piece_attack, bishop )
{
    ChessBoard board;

    {
        //.......*
        //*.....*.
        //.*...*..
        //..*.*...
        //...b....
        //..*.*...
        //.*...*..
        //*.....*.

        board.ClearBoard();
        board.PlacePiece( 3, 4, Piece::BLACK_BISHOP );

        ASSERT_TRUE( board.IsBishopAttack( 0, 1, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsBishopAttack( 1, 2, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsBishopAttack( 2, 3, PieceColor::BLACK ) );

        ASSERT_TRUE( board.IsBishopAttack( 7, 0, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsBishopAttack( 6, 1, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsBishopAttack( 5, 2, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsBishopAttack( 4, 3, PieceColor::BLACK ) );

        ASSERT_TRUE( board.IsBishopAttack( 2, 5, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsBishopAttack( 1, 6, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsBishopAttack( 0, 7, PieceColor::BLACK ) );

        ASSERT_TRUE( board.IsBishopAttack( 4, 5, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsBishopAttack( 5, 6, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsBishopAttack( 6, 7, PieceColor::BLACK ) );

        ASSERT_FALSE( board.IsBishopAttack( 3, 3, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsBishopAttack( 0, 0, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsBishopAttack( 2, 1, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsBishopAttack( 7, 7, PieceColor::BLACK ) );
    }

    {
        //.......*
        //*.......
        //.p...p..
        //........
        //...b....
        //........
        //.r...r..
        //*.....*.

        board.ClearBoard();
        board.PlacePiece( 3, 4, Piece::BLACK_BISHOP );
        board.PlacePiece( 1, 2, Piece::BLACK_PAWN );
        board.PlacePiece( 5, 2, Piece::BLACK_PAWN );
        board.PlacePiece( 1, 6, Piece::BLACK_ROOK );
        board.PlacePiece( 5, 6, Piece::BLACK_ROOK );

        ASSERT_FALSE( board.IsBishopAttack( 0, 1, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsBishopAttack( 7, 0, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsBishopAttack( 0, 7, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsBishopAttack( 6, 7, PieceColor::BLACK ) );
    }
}

TEST( piece_attack, queen )
{
    ChessBoard board;

    {
        //...*...*
        //*..*..*.
        //.*.*.*..
        //..***...
        //***q****
        //..***...
        //.*.*.*..
        //*..*..*.

        board.ClearBoard();
        board.PlacePiece( 3, 4, Piece::BLACK_QUEEN );

        ASSERT_TRUE( board.IsQueenAttack( 0, 1, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 1, 2, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 2, 3, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 7, 0, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 6, 1, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 5, 2, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 4, 3, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 2, 5, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 1, 6, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 0, 7, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 4, 5, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 5, 6, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 6, 7, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 3, 0, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 3, 1, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 3, 2, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 3, 3, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 3, 5, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 3, 6, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 3, 7, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 0, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 1, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 2, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 5, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 6, 4, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsQueenAttack( 7, 4, PieceColor::BLACK ) );

        ASSERT_FALSE( board.IsQueenAttack( 0, 3, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 0, 0, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 2, 1, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 7, 7, PieceColor::BLACK ) );
    }

    {
        //...*...*
        //*.......
        //........
        //..ppp...
        //*p.q.p.*
        //........
        //.p.p.p..
        //*..*..*.

        board.ClearBoard();
        board.PlacePiece( 3, 4, Piece::BLACK_QUEEN );
        board.PlacePiece( 1, 4, Piece::BLACK_PAWN );
        board.PlacePiece( 5, 4, Piece::BLACK_PAWN );
        board.PlacePiece( 2, 3, Piece::BLACK_PAWN );
        board.PlacePiece( 3, 3, Piece::BLACK_PAWN );
        board.PlacePiece( 4, 3, Piece::BLACK_PAWN );
        board.PlacePiece( 1, 6, Piece::BLACK_PAWN );
        board.PlacePiece( 3, 6, Piece::BLACK_PAWN );
        board.PlacePiece( 5, 6, Piece::BLACK_PAWN );

        ASSERT_FALSE( board.IsQueenAttack( 0, 1, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 3, 0, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 7, 0, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 0, 3, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 7, 3, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 0, 7, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 3, 7, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsQueenAttack( 6, 7, PieceColor::BLACK ) );
    }
}

TEST( piece_attack, knight )
{
    ChessBoard board;

    {
        //........
        //........
        //..*p*...
        //.*ppp*..
        //..pnp...
        //.*ppp*..
        //..*p*...
        //........

        board.ClearBoard();
        board.PlacePiece( 3, 4, Piece::BLACK_KNIGHT );
        board.PlacePiece( 3, 2, Piece::BLACK_PAWN );
        board.PlacePiece( 2, 3, Piece::BLACK_PAWN );
        board.PlacePiece( 3, 3, Piece::BLACK_PAWN );
        board.PlacePiece( 4, 3, Piece::BLACK_PAWN );
        board.PlacePiece( 2, 4, Piece::BLACK_PAWN );
        board.PlacePiece( 4, 4, Piece::BLACK_PAWN );
        board.PlacePiece( 2, 5, Piece::BLACK_PAWN );
        board.PlacePiece( 3, 5, Piece::BLACK_PAWN );
        board.PlacePiece( 4, 5, Piece::BLACK_PAWN );
        board.PlacePiece( 3, 6, Piece::BLACK_PAWN );

        ASSERT_TRUE( board.IsKnightAttack( 2, 2, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsKnightAttack( 4, 2, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsKnightAttack( 1, 3, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsKnightAttack( 5, 3, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsKnightAttack( 1, 5, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsKnightAttack( 5, 5, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsKnightAttack( 2, 6, PieceColor::BLACK ) );
        ASSERT_TRUE( board.IsKnightAttack( 4, 6, PieceColor::BLACK ) );

        ASSERT_FALSE( board.IsKnightAttack( 1, 2, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsKnightAttack( 2, 1, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsKnightAttack( 5, 2, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsKnightAttack( 1, 6, PieceColor::BLACK ) );
        ASSERT_FALSE( board.IsKnightAttack( 5, 6, PieceColor::BLACK ) );
    }
}

TEST( check_the_check, sample )
{
    {
        //..k.....
        //ppp.pppp
        //........
        //.R...B..
        //........
        //........
        //PPPPPPPP
        //K.......

        std::stringstream ss;
        ss << "..k....." << std::endl;
        ss << "ppp.pppp" << std::endl;
        ss << "........" << std::endl;
        ss << ".R...B.." << std::endl;
        ss << "........" << std::endl;
        ss << "........" << std::endl;
        ss << "PPPPPPPP" << std::endl;
        ss << "K......." << std::endl;

        ChessBoard board;
        board.Load( ss );
        ASSERT_STREQ( "black king is in check.", board.CheckTheCheck().c_str() );
    }

    {
        //rnbqkbnr
        //pppppppp
        //........
        //........
        //........
        //........
        //PPPPPPPP
        //RNBQKBNR

        std::stringstream ss;
        ss << "rnbqkbnr" << std::endl;
        ss << "pppppppp" << std::endl;
        ss << "........" << std::endl;
        ss << "........" << std::endl;
        ss << "........" << std::endl;
        ss << "........" << std::endl;
        ss << "PPPPPPPP" << std::endl;
        ss << "RNBQKBNR" << std::endl;

        ChessBoard board;
        board.Load( ss );
        ASSERT_STREQ( "no king is in check.", board.CheckTheCheck().c_str() );
    }

    {
        //rnbqk.nr
        //ppp..ppp
        //....p...
        //...p....
        //.bPP....
        //.....N..
        //PP..PPPP
        //RNBQKB.R

        std::stringstream ss;
        ss << "rnbqk.nr" << std::endl;
        ss << "ppp..ppp" << std::endl;
        ss << "....p..." << std::endl;
        ss << "...p...." << std::endl;
        ss << ".bPP...." << std::endl;
        ss << ".....N.." << std::endl;
        ss << "PP..PPPP" << std::endl;
        ss << "RNBQKB.R" << std::endl;

        ChessBoard board;
        board.Load( ss );
        ASSERT_STREQ( "white king is in check.", board.CheckTheCheck().c_str() );
    }
}

//#############################################################################A
int main(int argc, char **argv)
{
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}
#else
int main()
{
    //#########################################################################V
    // submit code

	int gameCount = 1;
	ChessBoard board;
	board.Load(std::cin);

	while (board.ExistBothKings())
	{
		std::cout << "Game #" << gameCount << ": "
			<< board.CheckTheCheck() << std::endl;

		// 한줄을 꿀꺽
		std::string dump;
		std::getline(std::cin, dump);

		board.Load(std::cin);
		++gameCount;
	}

    //#########################################################################A
    return 0;
}
#endif

아주 먼 옛날 짠 소스 코드

//////////////////////////////////////////////////////////////////////////
// Check The Check (UVa ID : 10196)
//
// Ohyecloudy ( Ohyecloudy@gmail.com )
// Accepted.

#include <iostream>

using namespace std ;

enum { BLACK_KING = 0, WHITE_KING = 32} ;
const int CHESS_BOARD_SIZE = 8 ;

char chessBoard[8][8] ;

bool isValid(int x, int y)
{
	if ( x < 0 || x > CHESS_BOARD_SIZE-1 || y < 0 || y > CHESS_BOARD_SIZE-1 )
		return false ;

	return true ;
}

char getChessPin(int x, int y)
{
	if ( !isValid(x,y) )
		return NULL ;

	return chessBoard[y][x] ;
}

bool pieceDiagonal( int cking, char pin, int x, int y )
{
	int theta = 1 ;

	if ( cking == WHITE_KING )
		theta = -1 ;

	if ( getChessPin(x-1, y+theta) == pin + cking )
		return true ;
	if ( getChessPin(x+1, y+theta) == pin + cking )
		return true ;

	return false ;
}

bool lShape( int cking, int pin, int x, int y )
{
	for ( int i = -2 ; i <= 2 ; i++ )
	{
		for ( int j = -2 ; j <=2 ; j++ )
		{
			if ( (i == j) || i == 0 || j == 0 || ( i == -1 * j ) )
				continue ;

			if ( getChessPin( x+i, y+j ) == pin + cking )
				return true ;
		}
	}

	return false ;
}

bool diagonally( int cking, int pin, int x , int y )
{
	int fact = 1 ;

	for ( int i = 1 ; i >= -1 ; i = i-2 )
	{
		for ( int j = 1 ; j >= -1 ; j = j-2 )
		{
			while ( getChessPin( x + i*fact, y + j*fact ) == '.' )
				fact++ ;

			if ( getChessPin( x + i*fact, y + j*fact ) == pin + cking )
				return true ;

			fact = 1 ;
		}
	}

	return false ;
}

bool horNVer( int cking, int pin, int x, int y )
{
	int fact = 1 ;

	for ( int i = -1 ; i <= 1 ; i++ )
	{
		for ( int j = -1 ; j <= 1 ; j++ )
		{
			if ( i != 0 && j != 0 || ( i == 0 && j == 0 ) )
				continue ;

			while ( getChessPin( x + i*fact , y + j*fact ) == '.' )
				fact++ ;

			if ( getChessPin( x + i*fact , y + j*fact ) == pin + cking)
				return true ;

			fact = 1 ;
		}
	}

	return false ;
}

bool isCheck(int cking, int x, int y)
{
	// Pawn
	if (pieceDiagonal( cking, 'P' , x, y ))
		return true ;

	// Rook
	if (horNVer( cking, 'R', x, y ))
		return true ;

	// Bishop
	if (diagonally( cking, 'B', x , y ))
		return true ;

	// Queen
	if (diagonally( cking, 'Q', x , y ) || horNVer( cking, 'Q', x, y ) )
		return true ;

	// Knight
	if (lShape( cking, 'N', x, y ))
		return true ;

	return false ;
}

main()
{
	int wKing[2] ;
	int bKing[2] ;
	int ID = 1 ;

	bool isEnd = false ;

	while (!isEnd)
	{
		isEnd = true ;

		for ( int i = 0 ; i < 8 ; ++i )
		{
			for ( int j = 0 ; j < 8 ; ++j )
			{
				cin >> chessBoard[i][j] ;

				if ( chessBoard[i][j] == 'k' )
				{
					bKing[0] = j ;
					bKing[1] = i ;

					isEnd = false ;
				}
				else if ( chessBoard[i][j] == 'K' )
				{
					wKing[0] = j ;
					wKing[1] = i ;

					isEnd = false ;
				}
			}
		}

		if (!isEnd)
		{
			cin.ignore(100,'\n') ; // eat one line.

			if ( isCheck(WHITE_KING, wKing[0], wKing[1] ) )
				cout << "Game #" << ID << ": white king is in check." << endl ;
			else if ( isCheck(BLACK_KING, bKing[0], bKing[1] ) )
				cout << "Game #" << ID << ": black king is in check." << endl ;
			else
				cout << "Game #" << ID << ": no king is in check." << endl ;

			ID++ ;
		}
	}
}

예전에 배웠던 어셈블리 생각이 나는 문제다. 문제에 적힌 대로 instruction들을 차례대로 RAM에 적재하고 나서 program counter를 0에서부터 진행하면 된다. 점프할 때 점프하고.

빈 줄 처리를 위해 getline()을 사용했다. 이렇게 되면 instruction을 int로 선언했기 때문에 변환이 필요한데, stringstream을 사용해서 변환했다.

PS : 유닛 테스트 감을 익혀가고 있는데, 이 문제는 모든 instruction을 테스트하지 않았다. 레지스터와 램 값을 볼 수 있는 함수를 추가해서 instruction들을 테스트할까 말까 고민하다가 단위가 너무 작아서 넘어갔다.

소스 코드

////////////////////////////////////////////////////////////////////////////////
// UVa Online Judge(http://uva.onlinejudge.org/)
//
// problem : 10033 Interpreter (http://uva.onlinejudge.org/external/100/10033.html)
//
// - OOP, Unit test, STL을 남발한다.
// - 속도보다는 읽기 좋게 작성한다.
//
// This file is licenced under a Creative Commons license:
// http://creativecommons.org/licenses/by-nc-arg2/2.0/kr/
////////////////////////////////////////////2009. 10. 05 ohyecloudy at gmail.com
//////////////////////////////////////////////////////http://ohyecloudy.com/algo

#ifdef ONLINE_JUDGE
#   define UNIT_TEST 0
#else
#   define UNIT_TEST 1
#endif  

#if UNIT_TEST
#	include <gtest/gtest.h>
#endif

#include <vector>
#include <sstream>
#include <iostream>
#include <string>

//#############################################################################V
// submit code

////////////////////////////////////////////////////////////////////////////////
class Value
{
public:
	Value()	: m_value( 0 )			{}
	Value( int value )				{ Set( value ); }
	~Value()						{}

	// All results are reduced modulo 1000.
	void	Set( int value )		{ m_value = value % 1000; }
	int		Get() const				{ return m_value; }

private:
	int m_value;
};

////////////////////////////////////////////////////////////////////////////////
class Interpreter
{
public:
	//--------------------------------------------------------------------------
	Interpreter()			{}

	//--------------------------------------------------------------------------
	~Interpreter()			{}

	//--------------------------------------------------------------------------
	void	LoadInstruction( int instruction )
	{
		m_ram.push_back( Value(instruction) );
	}

	//--------------------------------------------------------------------------
	int		Execute()
	{
		// register와 ram 사이즈를 제한 사항에 맞춘다.
		m_register.resize( 10 );
		m_ram.resize( 1000 );

		int pc = 0;		// program counter
		int execCount = 0;

		for( ;; )
		{
			pc = ExecuteInstruction( m_ram[pc].Get(), pc );
			execCount++;
			if( pc == -1  )
			{
				break;
			}
		}

		return execCount;
	}

	//--------------------------------------------------------------------------
	int		ExecuteInstruction( int instruction, int currentPc )
	{
		int opCode = 1;
		int arg1 = 0;
		int arg2 = 0;
		ParseInstruction( instruction, opCode, arg1, arg2 );

		int nextPc = currentPc + 1;

		switch( opCode )
		{
		case 1:
			// 100 means halt
			nextPc = -1;
			break;

		case 2:
			// 2dn means set register d to n (between 0 and 9)
			m_register[arg1].Set( arg2 );
			break;

		case 3:
			// 3dn means add n to register d
			m_register[arg1].Set( m_register[arg1].Get() + arg2 );
			break;

		case 4:
			// 4dn means multiply register d by n
			m_register[arg1].Set( m_register[arg1].Get() * arg2 );
			break;

		case 5:
			// 5ds means set register d to the value of register s
			m_register[arg1].Set( m_register[arg2].Get() );
			break;

		case 6:
			// 6ds means add the value of register s to register d
			m_register[arg1].Set(
				m_register[arg1].Get() + m_register[arg2].Get() );
			break;

		case 7:
			// 7ds means multiply register d by the value of register s
			m_register[arg1].Set(
				m_register[arg1].Get() * m_register[arg2].Get() );
			break;

		case 8:
			{
				// 8da means set register d to the value in RAM
				// whose address is in register a
				int ramAddr = m_register[arg2].Get();
				m_register[arg1].Set( m_ram[ramAddr].Get() );
			}
			break;

		case 9:
			{
				// 9sa means set the value in RAM
				// whose address is in register a to the value of register s
				int ramAddr = m_register[arg2].Get();
				m_ram[ramAddr].Set( m_register[arg1].Get() );
			}
			break;

		case 0:
			{
				// 0ds means goto the location in register d
				// unless register s contains 0
				if( m_register[arg2].Get() != 0 )
				{
					nextPc = m_register[arg1].Get();
				}
			}
			break;
		}

		return nextPc;
	}

	static void	ParseInstruction( int inst, int& opCode, int& arg1, int& arg2 )
	{
		opCode = inst / 100;
		arg1 = (inst - opCode * 100 ) / 10;		// first argument
		arg2 = inst - opCode * 100 - arg1 * 10;	// second argument
	}

private:
	std::vector<Value>				m_register;
	std::vector<Value>				m_ram;
};
//#############################################################################A

#if UNIT_TEST
//#############################################################################V
// test code
TEST( register, value_modulo_1000 )
{
	Value reg;
	reg.Set( 500 );
	ASSERT_EQ( reg.Get(), 500 );
	reg.Set( 1023 );
	ASSERT_EQ( reg.Get(), 23 );
}

TEST( interpreter, parse_instruction )
{
	int opCode, arg1, arg2;

	{
		Interpreter::ParseInstruction( 999, opCode, arg1, arg2 );
		ASSERT_EQ( opCode, 9 );
		ASSERT_EQ( arg1, 9 );
		ASSERT_EQ( arg2, 9 );
	}

	{
		Interpreter::ParseInstruction( 23, opCode, arg1, arg2 );
		ASSERT_EQ( opCode, 0 );
		ASSERT_EQ( arg1, 2 );
		ASSERT_EQ( arg2, 3 );
	}

	{
		Interpreter::ParseInstruction( 0, opCode, arg1, arg2 );
		ASSERT_EQ( opCode, 0 );
		ASSERT_EQ( arg1, 0 );
		ASSERT_EQ( arg2, 0 );
	}
}

TEST( interpreter, sample )
{
	Interpreter interpreter;
	interpreter.LoadInstruction(299);
	interpreter.LoadInstruction(492);
	interpreter.LoadInstruction(495);
	interpreter.LoadInstruction(399);
	interpreter.LoadInstruction(492);
	interpreter.LoadInstruction(495);
	interpreter.LoadInstruction(399);
	interpreter.LoadInstruction(283);
	interpreter.LoadInstruction(279);
	interpreter.LoadInstruction(689);
	interpreter.LoadInstruction(78);
	interpreter.LoadInstruction(100);
	interpreter.LoadInstruction(0);
	interpreter.LoadInstruction(0);
	interpreter.LoadInstruction(0);

	ASSERT_EQ( interpreter.Execute(), 16 );
}

//#############################################################################A
int main(int argc, char **argv)
{
	testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
}
#else
//#############################################################################V
// submit code

int ToInteger( const std::string& str )
{
	int integer;

	std::stringstream ss;
	ss << str;
	ss >> integer;

	return integer;
}

int main()
{
	std::string input;
	std::getline( std::cin, input );
	int caseCount = ToInteger( input );

	// case count와 첫번째 case 사이 빈줄을 꿀꺽.
	std::getline( std::cin, input );

	for( int i = 0; i < caseCount; ++i )
	{
		Interpreter interpreter;
		int instruction = 0;

		// 빈 줄이 나올때까지 명령을 RAM에 적재한다.
		while( std::getline( std::cin, input ) && !input.empty() )
		{
			instruction = ToInteger( input );
			interpreter.LoadInstruction( instruction );
		}

		std::cout << interpreter.Execute() << std::endl;

		// 답 사이에 공백이 있어야 한다.
		if( i + 1 < caseCount )
		{
			std::cout << std::endl;
		}
	}

	return 0;
}
//#############################################################################A
#endif

언젠지 기억도 안 나는 소스 코드

//////////////////////////////////////////////////////////////////////////
// Interpreter (UVa ID : 10033)
//
// Ohyecloudy ( Ohyecloudy@gmail.com )
// Accepted.

#include <iostream>
#include <cmath>

using namespace std ;

int registers[10] ;
int RAM[1000] ;

void setRegisters(int address, int value)
{
	registers[address] = value % 1000 ;
}

int getRegisters(int address)
{
	return registers[address] ;
}

void setRAM(int address, int value)
{
	RAM[address] = value % 1000 ;
}

int getRAM(int address)
{
	return RAM[address] ;
}

void init()
{
	for ( int i = 0 ; i < 10 ; ++i )
		registers[i] = 0 ;

	for ( int j = 0 ; j < 1000 ; ++j )
		RAM[j] = 0 ;
}

int execute()
{
	int pc = 0 ;
	int nExe = 0 ;
	int ins ;
	int temp = 0 ;
	int temp2 = 0 ;

	while ( RAM[pc] != 100 )
	{
		ins = RAM[pc] ;
		int secPara = (ins % 100) / 10;
		int thiPara = (ins % 10) ;

		switch ( ins / 100 )
		{
		case 2:
			setRegisters( secPara, thiPara ) ;
			nExe++ ;
			pc++ ;
			break ;

		case 3:
			temp = getRegisters( secPara ) ;
			setRegisters( secPara, temp + thiPara ) ;
			nExe++ ;
			pc++ ;
			break ;

		case 4:
			temp = getRegisters( secPara ) ;
			setRegisters( secPara, temp * thiPara ) ;
			pc++ ;
			nExe++ ;
			break ;

		case 5:
			temp = getRegisters( thiPara ) ;
			setRegisters( secPara, temp ) ;
			pc++ ;
			nExe++ ;
			break ;

		case 6:
			temp = getRegisters( thiPara ) ;
			temp2 = getRegisters( secPara ) ;
			setRegisters( secPara, temp + temp2 ) ;
			pc++ ;
			nExe++ ;
			break ;

		case 7:
			temp = getRegisters( secPara ) ;
			temp2 = getRegisters( thiPara ) ;
			setRegisters( secPara, temp * temp2 ) ;
			pc++ ;
			nExe++ ;
			break ;

		case 8:
			temp = getRAM ( getRegisters( thiPara ) ) ;
			setRegisters( secPara, temp ) ;
			pc++ ;
			nExe++ ;
			break ;

		case 9:
			temp = getRegisters( thiPara ) ;
			temp2 = getRegisters( secPara ) ;
			setRAM( temp, temp2 ) ;
			pc++ ;
			nExe++ ;
			break ;

		case 0:
			temp = getRegisters( thiPara ) ;
			bool isContainZero = false ;

			if ( temp == 0 )
				isContainZero = true ;

			if ( !isContainZero )
				pc = getRegisters( secPara ) ;
			else
				pc++ ;

			nExe++ ;

			break ;
		} // end switch
	} // end while

	return nExe + 1 ; // 1 is halt instruction
}

main()
{
	int nCase ;
	char input[4] ;
	int inputLoc = 0 ;
	int toInt = 0 ;

	cin.getline(input,4) ;
	nCase = (int)(input[0]-'0') ;

	cin.ignore(100, '\n') ; // eat one line

	for ( int i = 0 ; i < nCase ; ++i )
	{
		init() ;
		inputLoc = 0 ;

		while (1)
		{
			cin.getline(input, 4) ;

			if ( input[0] == NULL )
				break ;

			for ( int i = 0 ; i < 3 ; ++i )
				toInt += (input[i]  - '0')*pow(10,2-i) ;

			RAM[inputLoc] = toInt ;
			toInt = 0 ;
			inputLoc++ ;
		}

		cout << execute() << endl ;

		if ( i != nCase-1 )
			cout << endl ;
	}
}

리전을 채우는 명령어인 F는 그림판에 있는 색 채우기를 생각하면 된다. 간단하게 구현한다면 재귀 호출(recursive call)이나 큐(queue)를 사용하면 된다. 난 queue를 사용해서 해결.

딱딱 명령어가 나누어져 있어서 유닛 테스트를 연습하기에 딱 좋쿠나.

PS : 이거 예제가 너무 마음에 안 든다. 사실 색 채우기 명령어가 이 문제에서 핵심인데, 예제에서 이 명령어가 어떻게 동작하는지 자세히 나오지 않는다. 한번 죽어보라는 거지.

소스 코드

////////////////////////////////////////////////////////////////////////////////
// UVa Online Judge(http://uva.onlinejudge.org/)
//
// problem : 10267 Graphical Editor (http://uva.onlinejudge.org/external/102/10267.html)
//
// - OOP, Unit test, STL을 남발한다.
// - 속도보다는 읽기 좋게 작성한다.
//
// This file is licenced under a Creative Commons license:
// http://creativecommons.org/licenses/by-nc-sa/2.0/kr/
////////////////////////////////////////////2009. 10. 05 ohyecloudy at gmail.com
//////////////////////////////////////////////////////http://ohyecloudy.com/algo
#ifdef ONLINE_JUDGE
#   define UNIT_TEST 0
#else
#   define UNIT_TEST 1
#endif  

#if UNIT_TEST
#	include <gtest/gtest.h>
#	include <strstream>
#endif

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <limits>
#include <deque>

//#############################################################################V
// submit code
////////////////////////////////////////////////////////////////////////////////
// 좌표는 외부에서 zero-based index로 건내줘야 한다.
class GraphicalEditor
{
public:
	//--------------------------------------------------------------------------
	explicit GraphicalEditor( int width = 0, int height = 0 )
	{
		CreateTable( width, height );
	}

	//--------------------------------------------------------------------------
	~GraphicalEditor()	{}

	//--------------------------------------------------------------------------
	void CreateTable( int width, int height )
	{
		m_bitmapWidth = width;
		m_bitmapHeight = height;

		ResizeTable();
		ClearTable();
	}

	//--------------------------------------------------------------------------
	void ClearTable()
	{
		for( Bitmap::iterator iter = m_bitmap.begin();
			iter != m_bitmap.end(); ++iter )
		{
			BitmapCol& bitmapCol = *iter;
			std::fill( bitmapCol.begin(), bitmapCol.end(), 'O' );
		}
	}

	//--------------------------------------------------------------------------
	void DrawPixel( int x, int y, char color )
	{
		m_bitmap[x][y] = color;
	}

	//--------------------------------------------------------------------------
	void DrawVertical( int x, int y1, int y2, char color )
	{
		int lowerY = std::min( y1, y2 );
		int upperY = std::max( y1, y2 );

		for( int i = lowerY; i <= upperY; ++i )
		{
			m_bitmap[x][i] = color;
		}
	}

	//--------------------------------------------------------------------------
	void DrawHorizontal( int x1, int x2, int y, char color )
	{
		int leftX = std::min( x1, x2 );
		int rightX = std::max( x1, x2 );

		for( int i = leftX; i <= rightX; ++i )
		{
			m_bitmap[i][y] = color;
		}
	}

	//--------------------------------------------------------------------------
	void DrawRect( int x1, int y1, int x2, int y2, char color )
	{
		int leftX = std::min( x1, x2 );
		int rightX = std::max( x1, x2 );
		int lowerY = std::min( y1, y2 );
		int upperY = std::max( y1, y2 );

		for( int i = leftX; i <= rightX; ++i )
		{
			for( int j = lowerY; j <= upperY; ++j )
			{
				m_bitmap[i][j] = color;
			}
		}
	}

	//--------------------------------------------------------------------------
	void FillRegion( int x, int y, char targetColor )
	{
		char sourceColor = m_bitmap[x][y];
		m_bitmap[x][y] = targetColor;

		std::deque<BitmapCoord>		coordQueue;
		coordQueue.push_back( BitmapCoord(x, y) );

		while( !coordQueue.empty() )
		{
			BitmapCoord& current = coordQueue.front();
			const int curX = current.first;
			const int curY = current.second;

			coordQueue.pop_front();

			if( sourceColor == m_bitmap[x][y] )		continue;

			TestAndPushBack( curX,		curY-1,	sourceColor, targetColor, coordQueue );
			TestAndPushBack( curX,		curY+1,	sourceColor, targetColor, coordQueue );
			TestAndPushBack( curX-1,	curY,	sourceColor, targetColor, coordQueue );
			TestAndPushBack( curX+1,	curY,	sourceColor, targetColor, coordQueue );
		}
	}

	//--------------------------------------------------------------------------
	void Display( const std::string& filename, std::ostream& ost ) const
	{
		ost << filename << std::endl;
		Display( ost );
	}		

	//--------------------------------------------------------------------------
	void Display( std::ostream& ost ) const
	{
		for( int i = 0; i < m_bitmapHeight; ++i )
		{
			for( int j = 0; j < m_bitmapWidth; ++j )
			{
				ost << m_bitmap[j][i];
			}
			ost << std::endl;
		}
	}

private:
	typedef std::pair<int, int>			BitmapCoord;

private:
	//--------------------------------------------------------------------------
	void ResizeTable()
	{
		m_bitmap.resize( m_bitmapWidth );
		for( Bitmap::iterator iter = m_bitmap.begin();
			iter != m_bitmap.end(); ++iter )
		{
			iter->resize( m_bitmapHeight );
		}
	}

	//--------------------------------------------------------------------------
	void TestAndPushBack( int x, int y, char sourceColor, char targetColor,
		std::deque<BitmapCoord>& coordQueue )
	{
		if( x < 0 || x >= m_bitmapWidth )		return;
		if( y < 0 || y >= m_bitmapHeight )		return;

		if( m_bitmap[x][y] == sourceColor )
		{
			m_bitmap[x][y] = targetColor;
			coordQueue.push_back( BitmapCoord(x, y) );
		}
	}

private:
	typedef std::vector<char>			BitmapCol;
	typedef std::vector<BitmapCol>		Bitmap;
	Bitmap								m_bitmap;

	int									m_bitmapWidth;
	int									m_bitmapHeight;
};
//#############################################################################A

#if UNIT_TEST

//#############################################################################V
// test code
TEST( graphical_editor, create_table )
{
	{
		GraphicalEditor editor(1, 1);
		std::stringstream ss;
		editor.Display( ss );
		ASSERT_STREQ( "O\n", ss.str().c_str() );
	}
	{
		GraphicalEditor editor(1, 2);
		std::stringstream ss;
		editor.Display( ss );
		ASSERT_STREQ( "O\nO\n", ss.str().c_str() );
	}
	{
		GraphicalEditor editor(2, 1);
		std::stringstream ss;
		editor.Display( ss );
		ASSERT_STREQ( "OO\n", ss.str().c_str() );
	}
}

TEST( graphical_editor, draw_pixel )
{
	GraphicalEditor editor(3, 3);
	std::stringstream ss;
	{
		editor.DrawPixel( 0, 0, 'C' );
		editor.Display( ss );
		ASSERT_STREQ( "COO\nOOO\nOOO\n", ss.str().c_str() );
	}
	{
		ss.str("");
		editor.DrawPixel( 1, 0, 'L' );
		editor.Display( ss );
		ASSERT_STREQ( "CLO\nOOO\nOOO\n", ss.str().c_str() );
	}
	{
		ss.str("");
		editor.DrawPixel( 2, 2, 'K' );
		editor.Display( ss );
		ASSERT_STREQ( "CLO\nOOO\nOOK\n", ss.str().c_str() );
	}
}

TEST( graphical_editor, clear_table )
{
	GraphicalEditor editor(3, 3);
	std::stringstream ss;
	{
		editor.DrawPixel( 0, 0, 'C' );
		editor.DrawPixel( 0, 1, 'C' );
		editor.DrawPixel( 0, 2, 'C' );
		editor.DrawPixel( 1, 0, 'C' );
		editor.DrawPixel( 1, 1, 'C' );
		editor.DrawPixel( 1, 2, 'C' );
		editor.DrawPixel( 2, 0, 'C' );
		editor.DrawPixel( 2, 1, 'C' );
		editor.DrawPixel( 2, 2, 'C' );

		editor.Display( ss );
		ASSERT_STREQ( "CCC\nCCC\nCCC\n", ss.str().c_str() );
	}
	{
		editor.ClearTable();
		ss.str("");
		editor.Display( ss );
		ASSERT_STREQ( "OOO\nOOO\nOOO\n", ss.str().c_str() );
	}
}

TEST( graphical_editor, draw_vertical )
{
	GraphicalEditor editor(3, 3);
	std::stringstream ss;
	{
		editor.DrawVertical(1, 0, 2, 'C');
		editor.Display( ss );

		ASSERT_STREQ( "OCO\nOCO\nOCO\n", ss.str().c_str() );
	}
	{
		editor.DrawVertical(2, 2, 1, 'L');
		ss.str("");
		editor.Display( ss );

		ASSERT_STREQ( "OCO\nOCL\nOCL\n", ss.str().c_str() );
	}
}

TEST( graphical_editor, draw_horizontal )
{
	GraphicalEditor editor(3, 3);
	std::stringstream ss;
	{
		editor.DrawHorizontal(0, 2, 2, 'C');
		editor.Display( ss );
		ASSERT_STREQ( "OOO\nOOO\nCCC\n", ss.str().c_str() );
	}
	{
		editor.DrawHorizontal(0, 1, 1, 'L');
		ss.str("");
		editor.Display( ss );
		ASSERT_STREQ( "OOO\nLLO\nCCC\n", ss.str().c_str() );
	}
}

TEST( graphical_editor, draw_rect )
{
	GraphicalEditor editor(3, 3);
	std::stringstream ss;
	{
		editor.DrawRect(0, 0, 2, 2, 'C');
		editor.Display( ss );

		ASSERT_STREQ( "CCC\nCCC\nCCC\n", ss.str().c_str() );
	}
	{
		editor.DrawRect(0, 0, 1, 0, 'L');
		ss.str("");
		editor.Display( ss );

		ASSERT_STREQ( "LLC\nCCC\nCCC\n", ss.str().c_str() );
	}
	{
		editor.DrawRect(1, 1, 1, 2, 'K');
		ss.str("");
		editor.Display( ss );

		ASSERT_STREQ( "LLC\nCKC\nCKC\n", ss.str().c_str() );
	}
}

TEST( graphical_editor, fill_region )
{
	GraphicalEditor editor(3, 3);
	std::stringstream ss;
	{
		editor.FillRegion( 1, 1, 'C' );
		editor.Display( ss );
		ASSERT_STREQ( "CCC\nCCC\nCCC\n", ss.str().c_str() );
	}
	{
		editor.DrawPixel( 2, 2, 'L' );
		editor.FillRegion( 0, 0, 'K' );
		ss.str("");
		editor.Display( ss );
		ASSERT_STREQ( "KKK\nKKK\nKKL\n", ss.str().c_str() );
	}
	{
		editor.DrawHorizontal( 0, 2, 1, 'C' );
		editor.FillRegion( 0, 0, 'L' );
		ss.str("");
		editor.Display( ss );
		ASSERT_STREQ( "LLL\nCCC\nKKL\n", ss.str().c_str() );
	}
	{
		editor.ClearTable();
		editor.DrawPixel( 1, 1, 'C' );
		editor.FillRegion( 1, 1, 'L' );
		ss.str("");
		editor.Display( ss );
		ASSERT_STREQ( "OOO\nOLO\nOOO\n", ss.str().c_str() );
	}
	{
		editor.ClearTable();
		editor.DrawVertical( 2, 0, 2, 'C' );
		editor.FillRegion( 2, 2, 'C' );
		ss.str("");
		editor.Display( ss );
		ASSERT_STREQ( "OOC\nOOC\nOOC\n", ss.str().c_str() );
	}
	{
		editor.ClearTable();
		editor.FillRegion( 1, 1, 'O' );
		ss.str("");
		editor.Display( ss );
		ASSERT_STREQ( "OOO\nOOO\nOOO\n", ss.str().c_str() );
	}
}

TEST( graphical_editor, display )
{
	GraphicalEditor editor(3, 3);
	std::stringstream ss;
	editor.Display( "sample.bmp", ss );
	ASSERT_STREQ( "sample.bmp\nOOO\nOOO\nOOO\n", ss.str().c_str() );
}

//#############################################################################A

int main(int argc, char **argv)
{
	testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
}

#else

int main()
{
	//#########################################################################V
	// submit code
	char command;
	GraphicalEditor editor;

	while( (std::cin >> command) && command != 'X' )
	{
		switch( command )
		{
		case 'I':
			{
				int m, n;
				std::cin >> m >> n;
				editor.CreateTable( m, n );
			}
			break;

		case 'C':
			editor.ClearTable();
			break;

		case 'L':
			{
				int x, y;
				char c;
				std::cin >> x >> y >> c;
				editor.DrawPixel( x-1, y-1, c );
			}
			break;

		case 'V':
			{
				int x, y1, y2;
				char c;
				std::cin >> x >> y1 >> y2 >> c;
				editor.DrawVertical( x-1, y1-1, y2-1, c );
			}
			break;

		case 'H':
			{
				int x1, x2, y;
				char c;
				std::cin >> x1 >> x2 >> y >> c;
				editor.DrawHorizontal( x1-1, x2-1, y-1, c );
			}
			break;

		case 'K':
			{
				int x1, x2, y1, y2;
				char c;
				std::cin >> x1 >> y1 >> x2 >> y2 >> c;
				editor.DrawRect( x1-1, y1-1, x2-1, y2-1, c );
			}
			break;

		case 'F':
			{
				int x, y;
				char c;
				std::cin >> x >> y >> c;
				editor.FillRegion( x-1, y-1, c );
			}
			break;

		case 'S':
			{
				std::string fileName;
				std::cin >> fileName;
				editor.Display( fileName, std::cout );
			}
			break;

		default:
			// 라인 마지막까지 꿀꺽~
			std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );
			break;
		}
	}
	//#########################################################################A
	return 0;
}
#endif

문자와 문자 사이에 빈칸을 출력해야 하고 출력을 다 하고 빈 라인을 출력해야 한다. for_each로 문자의 row를 출력하려고 했는데, 마지막 문자 뒤에는 공백을 출력하면 안 돼서 그냥 반복자(iterator)를 사용해서 출력했다. 어렵기보단 귀찮은 문제..

소스 코드

////////////////////////////////////////////////////////////////////////////////
// UVa Online Judge(http://uva.onlinejudge.org/)
//
// problem : 706 LCD Display (http://uva.onlinejudge.org/external/7/706.html)
//
// - OOP, Unit test, STL을 남발한다.
// - 속도보다는 읽기 좋게 작성한다.
//
// This file is licenced under a Creative Commons license:
// http://creativecommons.org/licenses/by-nc-sa/2.0/kr/
////////////////////////////////////////////2009. 07. 12 ohyecloudy at gmail.com
#ifdef ONLINE_JUDGE
#   define UNIT_TEST 0
#else
#   define UNIT_TEST 1
#endif  

#if UNIT_TEST
#	include <gtest/gtest.h>
#	include <strstream>
#endif

#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
#include <string>
//-----------------------------------------------------------------------------V
// submit code
class Lcd
{
public:
	typedef std::vector<int>	digit_vec;
public:
	explicit Lcd( int digit, int scale )
		: m_scale( scale )
	{
		m_digitList.push_back(digit);
	}
	explicit Lcd( const std::vector<int>& digitList, int scale )
		: m_digitList( digitList )
		, m_scale( scale )
	{}

	void Display( std::ostream& ost)
	{
		DisplayRow( ost, 0 );

		// 2번째 줄을 스케일만큼 출력.
		for( int i = 0; i < m_scale; ++i )
		{
			DisplayRow( ost, 1 );
		}

		DisplayRow( ost, 2 );

		// 4번째 줄을 스케일만큼 출력.
		for( int i = 0; i < m_scale; ++i )
		{
			DisplayRow( ost, 3 );
		}

		DisplayRow( ost, 4 );
		// Output a blank line after each number.
		ost << std::endl;
	}
private:
	void DisplayRow( std::ostream& ost, int row )
	{
		for( digit_vec::iterator iter = m_digitList.begin();
			iter != m_digitList.end(); ++iter )
		{
			DisplayDigitRow( ost, *iter, row );

			// 현재 이터레이션이 마지막일때를 제외하고 출력한 공백 출력.
			// 문자 사이에 공백이 하나 있어야하고
			// 마지막에는 공백이 없어야 하기 때문.
			if( std::distance( iter, m_digitList.end() ) > 1 )
			{
				ost << ' ';
			}
		}
		ost << std::endl;
	}

	void DisplayDigitRow( std::ostream& ost, int num, int row )
	{
		static char digit[10][15] =
		{
			{' ','-',' ', '|',' ','|', ' ',' ',' ', '|',' ','|', ' ','-',' ',}, // 0
			{' ',' ',' ', ' ',' ','|', ' ',' ',' ', ' ',' ','|', ' ',' ',' ',}, // 1
			{' ','-',' ', ' ',' ','|', ' ','-',' ', '|',' ',' ', ' ','-',' ',}, // 2
			{' ','-',' ', ' ',' ','|', ' ','-',' ', ' ',' ','|', ' ','-',' ',}, // 3
			{' ',' ',' ', '|',' ','|', ' ','-',' ', ' ',' ','|', ' ',' ',' ',}, // 4
			{' ','-',' ', '|',' ',' ', ' ','-',' ', ' ',' ','|', ' ','-',' ',}, // 5
			{' ','-',' ', '|',' ',' ', ' ','-',' ', '|',' ','|', ' ','-',' ',}, // 6
			{' ','-',' ', ' ',' ','|', ' ',' ',' ', ' ',' ','|', ' ',' ',' ',}, // 7
			{' ','-',' ', '|',' ','|', ' ','-',' ', '|',' ','|', ' ','-',' ',}, // 8
			{' ','-',' ', '|',' ','|', ' ','-',' ', ' ',' ','|', ' ','-',' ',}, // 9
		};

		ost << digit[num][3 * row];

		// 2번째 열만 스케일만큼 출력한다.
		for( int i = 0; i < m_scale; ++i )
		{
			ost << digit[num][3 * row + 1];
		}

		ost << digit[num][3 * row+2];
	}

private:
	digit_vec			m_digitList;
	int					m_scale;
};

//-----------------------------------------------------------------------------A

#if UNIT_TEST
//-----------------------------------------------------------------------------V
// test code
TEST( singleDisplay_all, scale1 )
{
	{
		// 0
		Lcd lcd( 0, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( " - \n| |\n   \n| |\n - \n\n", ss.str().c_str() );
	}
	{
		// 1
		Lcd lcd( 1, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( "   \n  |\n   \n  |\n   \n\n", ss.str().c_str() );
	}
	{
		// 2
		Lcd lcd( 2, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( " - \n  |\n - \n|  \n - \n\n", ss.str().c_str() );
	}
	{
		// 3
		Lcd lcd( 3, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( " - \n  |\n - \n  |\n - \n\n", ss.str().c_str() );
	}
	{
		// 4
		Lcd lcd( 4, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( "   \n| |\n - \n  |\n   \n\n", ss.str().c_str() );
	}
	{
		// 5
		Lcd lcd( 5, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( " - \n|  \n - \n  |\n - \n\n", ss.str().c_str() );
	}
	{
		// 6
		Lcd lcd( 6, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( " - \n|  \n - \n| |\n - \n\n", ss.str().c_str() );
	}
	{
		// 7
		Lcd lcd( 7, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( " - \n  |\n   \n  |\n   \n\n", ss.str().c_str() );
	}
	{
		// 8
		Lcd lcd( 8, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( " - \n| |\n - \n| |\n - \n\n", ss.str().c_str() );
	}
	{
		// 9
		Lcd lcd( 9, 1 );

		std::stringstream ss;
		lcd.Display( ss );

		ASSERT_STREQ( " - \n| |\n - \n  |\n - \n\n", ss.str().c_str() );
	}
}

TEST( singleDisplay_0, scale2 )
{
	Lcd lcd( 0, 2 );

	std::stringstream ss;
	lcd.Display( ss );

	ASSERT_STREQ( " -- \n|  |\n|  |\n    \n|  |\n|  |\n -- \n\n", ss.str().c_str() );
}

TEST( twoDisplay_01, scale1 )
{
	std::vector<int> digitList;
	digitList.push_back( 0 );
	digitList.push_back( 1 );
	Lcd lcd( digitList, 1 );

	std::stringstream ss;
	lcd.Display( ss );

	ASSERT_STREQ( " -     \n| |   |\n       \n| |   |\n -     \n\n", ss.str().c_str() );
}
//-----------------------------------------------------------------------------A
int main( int argc, char **argv )
{
	testing::InitGoogleTest( &argc, argv );
	return RUN_ALL_TESTS();
}

#else

int main( int argc, char **argv )
{
	//-------------------------------------------------------------------------V
	// submit code
	int scale;
	std::string numberString;
	while( std::cin >> scale >> numberString )
	{
		if( scale == 0 )			break;

		Lcd::digit_vec numbers;
		for( std::string::iterator iter = numberString.begin();
			iter != numberString.end(); ++iter )
		{
			numbers.push_back( *iter - '0' );
		}

		Lcd lcd( numbers, scale );
		lcd.Display( std::cout );
	}

	//-------------------------------------------------------------------------A
	return 0;
}
#endif

찾아보니 예전에 풀었던 소스도 있었다. 코드 읽기가 너무 어려워… 게다가 무슨 깡으로 주석도 안 적었는지, 것 참.

예전 소스 코드

//////////////////////////////////////////////////////////////////////////
// LC-Display (UVa ID : 706)
//
// Ohyecloudy ( Ohyecloudy@gmail.com )
// Accepted

#include <iostream>
#include <string>

using namespace std ;

int LC[10][7] = { { 1,1,1,0,1,1,1 },
{ 0,0,1,0,0,1,0},
{ 1,0,1,1,1,0,1},
{ 1,0,1,1,0,1,1},
{ 0,1,1,1,0,1,0},
{ 1,1,0,1,0,1,1},
{ 1,1,0,1,1,1,1},
{ 1,0,1,0,0,1,0},
{ 1,1,1,1,1,1,1},
{ 1,1,1,1,0,1,1} } ;

void print(int input,char ch)
{
    for ( int i = 0 ; i < input ; ++i )
        cout << ch ;
}

void drawNumber(string num, int scale )
{
    int i,j,idx ;

    for ( i = 0 ; i < num.length() ; ++i )
    {
        idx = static_cast<int>(num.at(i) - '0') ;

        cout << " " ;

        if ( LC[idx][0] == 1 )
            print(scale, '-') ;
        else
            print(scale, ' ') ;

        if ( i == num.length() - 1 )
            cout <<  " "  << endl ;
        else
            cout <<  "  " ;
    }

    for ( i = 0 ; i < scale ; ++i )
    {
        for ( j = 0 ; j < num.length() ; ++j )
        {
            idx = static_cast<int>(num.at(j) - '0') ;

            if ( LC[idx][1] == 1 )
                cout << '|' ;
            else
                cout << ' ' ;

            print(scale, ' ') ;

            if ( LC[idx][2] == 1 )
                cout << '|' ;
            else
                cout << ' ' ;

            if ( j == num.length()-1 )
                cout << endl ;
            else
                cout << ' ' ;
        }
    }

    for ( i = 0 ; i < num.length() ; ++i )
    {
        idx = static_cast<int>(num.at(i) - '0') ;

        cout << " " ;

        if ( LC[idx][3] == 1 )
            print(scale, '-') ;
        else
            print(scale, ' ') ;

        if ( i == num.length() - 1 )
            cout <<  " "  << endl ;
        else
            cout <<  "  " ;
    }

    for ( i = 0 ; i < scale ; ++i )
    {
        for ( j = 0 ; j < num.length() ; ++j )
        {
            idx = static_cast<int>(num.at(j) - '0') ;

            if ( LC[idx][4] == 1 )
                cout << '|' ;
            else
                cout << ' ' ;

            print(scale, ' ') ;

            if ( LC[idx][5] == 1 )
                cout << '|' ;
            else
                cout << ' ' ;

            if ( j == num.length()-1 )
                cout << endl ;
            else
                cout << ' ' ;
        }
    }

    for ( i = 0 ; i < num.length() ; ++i )
    {
        idx = static_cast<int>(num.at(i) - '0') ;

        cout << " " ;

        if ( LC[idx][6] == 1 )
            print(scale, '-') ;
        else
            print(scale, ' ') ;

        if ( i == num.length() - 1 )
            cout <<  " "  << endl ;
        else
            cout <<  "  " ;
    }
}

main()
{
    string input ;
    int scale ;

    while ( cin >> scale >> input )
    {
        if ( scale == 0 )
        {
            if ( input.compare("0") == 0 )
                break ;
            else
                continue ;
        }

        drawNumber(input, scale ) ;
        cout << endl ;
    }
}

소스코드

////////////////////////////////////////////////////////////////////////////////
// UVa Online Judge(http://icpcres.ecs.baylor.edu/onlinejudge/)
//
// problem : 10137 - The Trip
// (http://uva.onlinejudge.org/external/101/10137.html)
//
// OOP, Unit test, STL을 연습하기 위함
//
// This file is licenced under a Creative Commons license:
// http://creativecommons.org/licenses/by-nc-sa/2.0/kr/
///////////////////////////////////////////////2009. 01. 28 ohyecloudy@gmail.com

#if ONLINE_JUDGE
#	define UNIT_TEST 0
#else
#	define UNIT_TEST 1
#endif

#if UNIT_TEST
#	include <gtest/gtest.h>
#endif

#include <iostream>
#include <iomanip>
#include <algorithm>
#include <limits>
#include <vector>
#include <cmath>
//-----------------------------------------------------------------------------V
// submit code
namespace
{
	// 평균값을 구하는 functor
	class MeanValue
	{
	public:
		MeanValue() : m_sum(0.0f), m_count(0)		{}

		void operator() (double elem)
		{
			m_sum += elem;
			++m_count;
		}

		operator double()							{ return m_sum / m_count; }

	private:
		double	m_sum;
		int		m_count;
	};
}

////////////////////////////////////////////////////////////////////////////////
// TravelExpense
class TravelExpense
{
public:
	explicit TravelExpense(int expenseCount) : m_expenseCount(expenseCount)
	{
		m_expenseList.reserve(expenseCount);
	}

	std::ostream& operator>> (std::ostream& ost)
	{
		ost << "$" << std::fixed << std::showpoint << std::setprecision(2) <<
			GetMinExchange() << std::endl;
		return ost;
	}

	std::istream& operator<< (std::istream& ist)
	{
		for (int i = 0; i < m_expenseCount; ++i)
		{
			double expense;
			ist >> expense;
			AddExpense(expense);
		}
		return ist;
	}

protected:
	void	AddExpense(double expense)	{ m_expenseList.push_back(expense); }

	double	GetMinExchange() const
	{
		// 소수점 셋째 자리에서 반올림한 평균값
		double meanValue = for_each(m_expenseList.begin(), m_expenseList.end(), MeanValue());
		meanValue = floor((meanValue + 0.005) * 100.0) * 0.01;

		double meanValueOver = 0.0;
		double meanValueUnder = 0.0;
		for (std::vector<double>::const_iterator iter = m_expenseList.begin();
			iter != m_expenseList.end(); ++iter)
		{
			const double expense = *iter;
			if (expense > meanValue)	meanValueOver	+= expense - meanValue;
			else						meanValueUnder	+= meanValue - expense;
		}

		// 평균 이상에서 평균을 뺀 값을 더한 총합이 단 하나의 경우를 제외하고는 항상 작다.
		// 단 하나의 경우는 1 센트 오차를 인정해서 평균에서 평균 이하 값을 뺀 총합이 0이
		// 되는 경우. 예) 12.00, 12.00, 12.00, 12.01
		return std::min<double>(meanValueOver, meanValueUnder);
	}

private:
	std::vector<double>		m_expenseList;
	int						m_expenseCount;
};

std::ostream& operator<< (std::ostream& ost, TravelExpense& travelExpense)
{
	travelExpense >> ost;
	return ost;
}

std::istream& operator>> (std::istream& ist, TravelExpense& travelExpense)
{
	travelExpense << ist;
	return ist;
}

//-----------------------------------------------------------------------------A

#if UNIT_TEST
//-----------------------------------------------------------------------------V
// test code
class TestTravelExpense : public TravelExpense
{
public:
	explicit TestTravelExpense(int expenseCount) : TravelExpense(expenseCount)	{}

	using TravelExpense::AddExpense;
	using TravelExpense::GetMinExchange;
};

TEST(GetMinExchange, ExchangeZero_1)
{
	TestTravelExpense travelExpense(0);

	for (int i=0; i < 999; ++i)
	{
		travelExpense.AddExpense(10000.00);
	}

	travelExpense.AddExpense(9999.99);

	ASSERT_DOUBLE_EQ(0.00, travelExpense.GetMinExchange());
}

TEST(GetMinExchange, ExchangeZero_2)
{
	TestTravelExpense travelExpense(0);

	travelExpense.AddExpense(12.01);
	travelExpense.AddExpense(12.00);
	travelExpense.AddExpense(12.00);
	travelExpense.AddExpense(12.00);

	ASSERT_DOUBLE_EQ(0.00, travelExpense.GetMinExchange());
}

TEST(GetMinExchange, ProblemSample_1)
{
	TestTravelExpense travelExpense(0);

	travelExpense.AddExpense(10.00);
	travelExpense.AddExpense(20.00);
	travelExpense.AddExpense(30.00);
	ASSERT_DOUBLE_EQ(10.0, travelExpense.GetMinExchange());
}

TEST(GetMinExchange, ProblemSample_2)
{
	TestTravelExpense travelExpense(0);

	travelExpense.AddExpense(15.00);
	travelExpense.AddExpense(15.01);
	travelExpense.AddExpense(3.00);
	travelExpense.AddExpense(3.01);
	ASSERT_DOUBLE_EQ(11.99, travelExpense.GetMinExchange());
}

//-----------------------------------------------------------------------------A
int main(int argc, char **argv)
{
	testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
}

#else
int main(int argc, char **argv)
{
	//-------------------------------------------------------------------------V
	// submit code
	int expenseCount;
	std::cin >> expenseCount;

	while ( expenseCount > 0)
	{
		TravelExpense travelExpense(expenseCount);
		std::cin >> travelExpense;
		std::cout << travelExpense;

		std::cin >> expenseCount;
	}

	//-------------------------------------------------------------------------A
	return 0;
}
#endif

오차 범위를 확인 안 하고 막 float 자료형을 써서 WA를 계속 받았던 문제였다. double 자료형을 사용해야지 Round-off 에러를 피할 수 있다. 평균값을 반올림해서 구하고 평균 이상 값과 평균 이하 값에서 평균값을 뺀 총합을 구하고 그 중 최솟값을 구하면 된다. 간단한 문제인데, 자료형 선택에서 실수를 많이 하는 문제이다.

예전 소스 코드

//////////////////////////////////////////////////////////////////////////
// The Trip (UVa ID : 10137)
//
// Ohyecloudy ( Ohyecloudy@gmail.com )
// Accepted

#include <iostream>
#include <cmath>
#include <iomanip>

using namespace std ;

long double money[1000] ;
int nStudent ;

long double round( int n, long double input )
{
	return floor( input * pow ( 10.0, n ) + 0.5 ) / pow ( 10.0, n ) ;
}

long double getExchange()
{
	long double tot = 0 ;

	for ( int i = 0 ; i < nStudent ; ++i )
		tot += money[i] ;

	long double avg = round( 2, tot / nStudent ) ;

	long double incomeToAvg = 0 ;
	long double outcomeToAvg = 0 ;

	for ( int j = 0 ; j < nStudent ; ++j )
	{
		if ( money[j] > avg )
			outcomeToAvg += money[j] - avg ;
		else
			incomeToAvg += avg - money[j] ;
	}

	if ( outcomeToAvg == 0 )
		outcomeToAvg = incomeToAvg ;
	if ( incomeToAvg == 0 )
		incomeToAvg = outcomeToAvg ;

	if ( incomeToAvg > outcomeToAvg )
		return outcomeToAvg ;
	else
		return incomeToAvg ;
}

main()
{
	while ( cin >> nStudent )
	{
		if ( nStudent == 0 )
			break ;

		for ( int i = 0 ; i < nStudent ; ++i )
			cin >> money[i] ;

		cout.setf( ios::showpoint | ios::fixed ) ;

		cout << "$" << setprecision(2) << getExchange() << endl ;
	}
}

왜 0일때 특별 처리를 해주는지 모르겠다. -_-; 저렇게 해도 AC가 뜬다. 미래의 나를 위해 주석을 달았어야 하는데 말이지…

소스코드

////////////////////////////////////////////////////////////////////////////////
// UVa Online Judge(http://icpcres.ecs.baylor.edu/onlinejudge/)
//
// problem : 10189 - Minesweeper
// (http://uva.onlinejudge.org/external/101/10189.html)
//
// OOP, Unit test, STL을 연습하기 위함
//
// This file is licenced under a Creative Commons license:
// http://creativecommons.org/licenses/by-nc-sa/2.0/kr/
///////////////////////////////////////////////2009. 01. 13 ohyecloudy@gmail.com

#define UNIT_TEST 0

#if UNIT_TEST
#	include <gtest/gtest.h>
#endif

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

//-----------------------------------------------------------------------------V
// submit code
class MineField
{
	// public-------------------------------------------------------------------
public:
	explicit MineField(int height, int width, int fieldNumber)
		: m_height(height), m_width(width), m_fieldNumber(fieldNumber)
	{
		m_mineLocationList.reserve(width*height);

		m_field.resize(width);
		for (field::iterator iter = m_field.begin(); iter != m_field.end(); ++iter)
		{
			std::vector<char>& col = *iter;
			col.resize(height);
			std::fill( col.begin(), col.end(), '0');
		}
	}

	void Sweep()
	{
		for (mine_location_list::const_iterator iter = m_mineLocationList.begin();
			iter != m_mineLocationList.end(); ++iter)
		{
			const mine_location& location = *iter;
			m_field[location.first][location.second] = MINE_MARK;
			UpdateMineAround(location.first, location.second);
		}

		m_mineLocationList.clear();
	}

	std::istream& operator<< (std::istream& ist)
	{
		char input;

		for (int i = 0; i < m_height; ++i)
		{
			for (int j = 0; j < m_width; ++j)
			{
				ist >> input;
				if (input == MINE_MARK)		AddMine( j, i );
			}
		}

		return ist;
	}

	std::ostream& operator>> (std::ostream& ost) const
	{
		ost << "Field #" << m_fieldNumber << ":" << std::endl;
		for (int i = 0; i < m_height; ++i)
		{
			for (int j = 0; j < m_width; ++j)
			{
				ost << GetField(j, i);
			}

			ost << std::endl;
		}

		return ost;
	}

	// protected----------------------------------------------------------------
protected:
	const static char							MINE_MARK;

protected:
	void AddMine(int x, int y)
	{
		if (m_field[x][y] != MINE_MARK )
		{
			m_mineLocationList.push_back( mine_location_value(x,y) );
		}
	}

	const char GetField(int x, int y) const		{ return m_field[x][y]; }

	// private------------------------------------------------------------------
private:
	int m_width, m_height, m_fieldNumber;

	typedef std::pair<int, int>					mine_location;
	typedef	std::vector<mine_location>			mine_location_list;
	typedef mine_location_list::value_type		mine_location_value;
	mine_location_list							m_mineLocationList;

	// 인접한 mine 개수가 최대 8이다. 2자리수가 될 수 없으므로 char 선택.
	typedef std::vector< std::vector<char> >	field;
	field										m_field;

private:
	void IncreaseMineSweep(int x, int y)
	{
		if (m_field[x][y] != MINE_MARK )	m_field[x][y]++;
	}

	void UpdateMineAround(int x, int y)
	{
		bool bTop		= (y-1 >= 0)		? true : false;
		bool bBottom	= (y+1 < m_height)	? true : false;
		bool bLeft		= (x-1 >= 0)		? true : false;
		bool bRight		= (x+1 < m_width)	? true : false;

		// horizon, vertical
		if (bTop)				IncreaseMineSweep(x,	y-1);
		if (bBottom)			IncreaseMineSweep(x,	y+1);
		if (bLeft)				IncreaseMineSweep(x-1,	y);
		if (bRight)				IncreaseMineSweep(x+1,	y);

		// diagonal
		if (bTop && bLeft)		IncreaseMineSweep(x-1,	y-1);
		if (bTop && bRight)		IncreaseMineSweep(x+1,	y-1);
		if (bBottom && bLeft)	IncreaseMineSweep(x-1,	y+1);
		if (bBottom && bRight)	IncreaseMineSweep(x+1,	y+1);
	}
};

const char MineField::MINE_MARK = '*';

std::istream& operator>> (std::istream& ist, MineField& mineField)
{
	mineField << ist;
	return ist;
}

std::ostream& operator<< (std::ostream& ost, const MineField& mineField)
{
	mineField >> ost;
	return ost;
}

//-----------------------------------------------------------------------------A

#if UNIT_TEST
//-----------------------------------------------------------------------------V
// test code
class TestMineField : public MineField
{
public:
	explicit TestMineField(int width, int height, int fieldNumber)
		: MineField(width, height, fieldNumber)
	{}

	// delegate
	using MineField::AddMine;
	using MineField::GetField;
	using MineField::MINE_MARK;
};

TEST(MineField, Sweep1x1Field)
{
	TestMineField	mineField( 1, 1, 1 );
	mineField.AddMine( 0, 0 );
	mineField.Sweep();

	ASSERT_EQ(TestMineField::MINE_MARK, mineField.GetField(0,0));
}

TEST(MineField, Sweep3x3FieldCenterMine)
{
	TestMineField	mineField( 3, 3, 1 );
	mineField.AddMine( 1, 1 );
	mineField.Sweep();

	ASSERT_EQ(TestMineField::MINE_MARK, mineField.GetField(1,1));
	ASSERT_EQ('1', mineField.GetField(0,0));
	ASSERT_EQ('1', mineField.GetField(0,1));
	ASSERT_EQ('1', mineField.GetField(0,2));
	ASSERT_EQ('1', mineField.GetField(1,0));
	ASSERT_EQ('1', mineField.GetField(1,2));
	ASSERT_EQ('1', mineField.GetField(2,0));
	ASSERT_EQ('1', mineField.GetField(2,1));
	ASSERT_EQ('1', mineField.GetField(2,2));
}

TEST(MineField, Sweep2x3FieldAdjacentTwoMine)
{
	TestMineField	mineField( 2, 3, 1 );
	mineField.AddMine( 0, 0 );
	mineField.AddMine( 1, 1 );
	mineField.Sweep();

	ASSERT_EQ(TestMineField::MINE_MARK, mineField.GetField(0,0));
	ASSERT_EQ(TestMineField::MINE_MARK, mineField.GetField(1,1));
	ASSERT_EQ('2', mineField.GetField(1,0));
	ASSERT_EQ('1', mineField.GetField(2,0));
	ASSERT_EQ('2', mineField.GetField(0,1));
	ASSERT_EQ('1', mineField.GetField(2,1));
}

//-----------------------------------------------------------------------------A
int main(int argc, char **argv)
{
	testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
}
#else
int main(int argc, char **argv)
{
	//-------------------------------------------------------------------------V
	// submit code
	int fieldNumber = 1;

	int row, col;
	while (std::cin >> row >> col)
	{
		if (row == 0 || col == 0)	break;

		MineField	mineField(row, col, fieldNumber);
		std::cin >> mineField;
		mineField.Sweep();

		if (fieldNumber != 1)		std::cout << std::endl;
		std::cout << mineField;
		++fieldNumber;
	}
	//-------------------------------------------------------------------------A
	return 0;
}
#endif

MineSweeper를 class 이름으로 했는데, 지뢰를 제거하는 함수 네이밍이 애매했다. 그래서 MineField로 이름을 변경하고 지뢰를 제거하는 함수 이름을 Sweep()이라 정했다. row, col, field number로 MineField를 생성하고 Sweep()으로 지뢰를 제거, 네이밍을 잘한 것 같다.

결과를 스트링으로 출력하려고 했는데, string 생성, 소멸 비용이 아까웠다. 그래서 output stream으로 출력했다. 또한 input 파싱을 클래스 외부에서 하고 AddMine 함수로 입력하려고 했는데, input 값이 이상하게 들어오지 않는다는 전제 조건이 있기 때문에, 마음 편하게 클래스 내부에서 input stream을 받아서 파싱하는 걸로 변경했다.

MineField를 상속받은 TestMineField 클래스에서 MineField의 protected 멤버 함수를 호출하기 위해서 public 멤버 함수를 만들고 멤버 함수에서 protected 함수를 호출했었는데, 이렇게 손이 괴로울 필요 없이 using MineField::[protected member function] 으로 간단하게 delegate를 사용할 수 있다. Working effectively with legacy code 책에서 배웠는데, 테스트 클래스를 만들 때 유용하게 사용할 것 같다.

예전 소스 코드

//////////////////////////////////////////////////////////////////////////
// Minesweeper (UVa ID : 10189)
//
// Ohyecloudy ( Ohyecloudy@gmail.com )
// Accepted

#include <iostream>
using namespace std ;

char** field ;
int numRow, numCol ;

bool IsMine(int i, int j)
{
	if ( field[i][j] == '*' )
		return true ;
	else
		return false ;
}

void checkMineAround(int i, int j)
{
	// up is valid and not exist mine
	if ( i-1 >= 0 && !IsMine(i-1,j) )
		field[i-1][j]++ ;

	// down ..
	if ( i+1 < numRow && !IsMine(i+1, j) )
		field[i+1][j]++ ;

	// left ..
	if ( j-1 >= 0 && !IsMine(i, j-1) )
		field[i][j-1]++ ;

	// right ..
	if ( j+1 < numCol && !IsMine(i, j+1) )
		field[i][j+1]++ ;

	// up & left ..
	if ( i-1 >= 0 && j-1 >=0 && !IsMine(i-1,j-1) )
		field[i-1][j-1]++ ;

	// up & right ..
	if ( i-1 >= 0 && j+1 < numCol && !IsMine(i-1,j+1) )
		field[i-1][j+1]++ ;

	// down & left ..
	if ( i+1 < numRow && j-1 >= 0 && !IsMine(i+1, j-1) )
		field[i+1][j-1]++ ;

	// down & right ..
	if ( i+1 < numRow && j+1 < numCol && !IsMine(i+1, j+1) )
		field[i+1][j+1]++ ;
}

void BuildField()
{
	for ( int i = 0 ; i < numRow ; ++i )
	{
		for ( int j = 0 ; j < numCol ; ++j )
		{
			if ( field[i][j] == '*' )
				checkMineAround(i,j) ;
		}
	}
}

main()
{
	char temp[101] ;
	int num = 1 ;

	while( cin >> numRow >> numCol )
	{
		if ( numRow == 0 && numCol == 0 )
			break ;

		if ( num != 1 )
			cout << endl ;

		field = new char*[numRow] ;

		for ( int i = 0 ; i < numRow ; ++i )
		{
			field[i] = new char[numCol] ;

			cin >> temp ;

			for ( int k = 0 ; k < numCol ; ++k )
			{
				if ( temp[k] == '.' )
					field[i][k] = '0' ;
				else if ( temp[k] == '*' )
					field[i][k] = temp[k] ;
			}
		}

		BuildField() ;

		cout << "Field #" << num << ":" << endl ;

		for ( int j = 0 ; j < numRow ; ++j )
		{
			for ( int k = 0 ; k < numCol ; ++k )
				cout << field[j][k] ;

			cout << endl ;
		}

		for ( int l = 0 ; l < numRow ; ++l )
			delete [] field[l] ;
		delete [] field ;

		num++ ;
	}
}

언젠지 모르는 예전 코드. 보니깐 재미있다. 나중에 이 문제를 다시 풀어볼 때는 어떻게 작성할까?

소스 코드

////////////////////////////////////////////////////////////////////////////////
// UVa Online Judge(http://icpcres.ecs.baylor.edu/onlinejudge/)
//
// problem : 100 - The 3n + 1 problem
// (http://uva.onlinejudge.org/external/1/100.html)
//
// OOP, Unit test, STL을 연습하기 위함
//
// This file is licenced under a Creative Commons license:
// http://creativecommons.org/licenses/by-nc-sa/2.0/kr/
///////////////////////////////////////////////2009. 01. 02 ohyecloudy@gmail.com
//////////////////////////////////////////////////////http://ohyecloudy.com/algo

#define UNIT_TEST 0

#if UNIT_TEST
#	include <gtest/gtest.h>
#endif

#include <iostream>
#include <limits>
#include <vector>
#include <algorithm>

#include <cassert>
//-----------------------------------------------------------------------------V
// submit code
class The3nPlus1Generator
{
public:
	explicit The3nPlus1Generator(int leftBorder, int rightBorder)
	{
		m_minBorder = std::min(leftBorder, rightBorder);
		m_maxBorder = std::max(leftBorder, rightBorder);
	}

	int	GetMaximumCycleLength()
	{
		m_cacheCount.resize(m_maxBorder-m_minBorder+1);
		std::fill(m_cacheCount.begin(), m_cacheCount.end(), 0);

		int maxCycleLength = std::numeric_limits<int>::min();
		for ( int i = m_minBorder; i <= m_maxBorder; ++i )
		{
			maxCycleLength = std::max(GetCycleLength(i), maxCycleLength);
		}

		return maxCycleLength;
	}

private:
	int						m_minBorder, m_maxBorder;
	std::vector<int>		m_cacheCount;

private:
	int GetCycleLength(int number)
	{
		assert(number >= 1);
		if (number < 1)			return 0;

		int cycle = 0;
		int currentNumber = number;
		while (currentNumber != 1)
		{
			//-----------------------------------------------------------------V
			// cycle length를 캐싱해서 퍼포먼스를 높인다.
			if (m_minBorder <= currentNumber && currentNumber <= m_maxBorder)
			{
				int currentNumberIndex = currentNumber-m_minBorder;

				// 캐시된 cycle length count가 있으면 사용한다.
				if (m_cacheCount[currentNumberIndex] > 0)
				{
					int retCycle = cycle + m_cacheCount[currentNumberIndex];

					return retCycle;
				}
				else if (currentNumber != number &&
						m_cacheCount[currentNumberIndex] == 0)
				{
					// 캐시된 cycle length count가 없으면
					// 바로 그 숫자의 cycle length를 구한다.
					// 무한 루프를 방지하기 위해 숫자가 다른지 확인.
					m_cacheCount[currentNumberIndex] =
						GetCycleLength(currentNumber);

					return cycle + m_cacheCount[currentNumberIndex];
				}
			}
			//-----------------------------------------------------------------A

			cycle++;

			if (currentNumber % 2 == 1)
			{
				currentNumber = currentNumber * 3 + 1;	// odd
			}
			else
			{
				currentNumber /= 2;						// even
			}
		}

		// 1일때 싸이클 횟수를 더해준다.
		cycle++;

		return cycle;
	}
};
//-----------------------------------------------------------------------------A

#if UNIT_TEST
//-----------------------------------------------------------------------------V
// test code
TEST(The3nPlus1Generator, SameInputBorder)
{
	EXPECT_EQ( 1, The3nPlus1Generator(1,1).GetMaximumCycleLength());
	EXPECT_EQ( 16, The3nPlus1Generator(22,22).GetMaximumCycleLength());
}

TEST(The3nPlus1Generator, ProblemSample)
{
	EXPECT_EQ( 20, The3nPlus1Generator(1,10).GetMaximumCycleLength());
	EXPECT_EQ( 125, The3nPlus1Generator(100,200).GetMaximumCycleLength());
	EXPECT_EQ( 89, The3nPlus1Generator(201,210).GetMaximumCycleLength());
	EXPECT_EQ( 174, The3nPlus1Generator(900,1000).GetMaximumCycleLength());
}

TEST(The3nPlus1Generator, ProblemSampleReserveInput)
{
	EXPECT_EQ( 20, The3nPlus1Generator(10,1).GetMaximumCycleLength());
	EXPECT_EQ( 125, The3nPlus1Generator(200,100).GetMaximumCycleLength());
	EXPECT_EQ( 89, The3nPlus1Generator(210,201).GetMaximumCycleLength());
	EXPECT_EQ( 174, The3nPlus1Generator(1000,900).GetMaximumCycleLength());
}

//-----------------------------------------------------------------------------A
int main(int argc, char **argv)
{
	testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
}
#else
int main(int argc, char **argv)
{
	//-------------------------------------------------------------------------V
	// submit code
	int leftBorder, rightBorder;
	while ( std::cin >> leftBorder >> rightBorder )
	{
		std::cout << leftBorder << " " << rightBorder << " "
			<< The3nPlus1Generator(leftBorder, rightBorder).
				GetMaximumCycleLength()
			<< std::endl;
	}	

	//-------------------------------------------------------------------------A
	return 0;
}
#endif

입력값이 반드시 min, max 순으로 들어오지 않는다. 이것만 주의하면 된다. cycle length를 캐싱하니 6배 퍼포먼스 향상이 있다.

옛날 옛적 코드.

#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;

long* icycleLength ;
long numTerm ;

long cycleLength(long input, long start, long end )
{
	long current = input ;
	long cycleLength = 0 ;

	while ( current != 1 )
	{
		if ( current >= start && current <= end && icycleLength[current-start] != -1 )
		{
			cycleLength += icycleLength[current-start] -1 ;
			// -1의 이유는 while loop 끝나고 1을 포함하기 위해 1더하는 것이랑
			// icycleLength array의 값이 1을 포함하고 있는 것이 중복 되기 때문.
			break ;
		}

		if ( current % 2 == 0 ) // even
		{
			current /= 2 ;
			cycleLength++ ;
		}
		else // odd
		{
			current = current * 3 + 1 ;
			cycleLength++ ;
		}
	}

	cycleLength++ ;
	/// include 1

	return cycleLength ;
}

// start~end 사이의 모든 cycle계산
// return cycle
long calcyclelength(long start, long end)
{
	long i ;

	numTerm = end-start + 1 ;

	icycleLength = new long[numTerm] ;
	for ( i = 0 ; i < numTerm ; ++i )
		icycleLength[i] = -1 ;

	// start의 cycleLength 계산.
	long max = cycleLength( start, start, end ) ;
	icycleLength[0] = max ;

	for ( i = 1 ; i < numTerm ; ++i )
	{
		long temp = cycleLength(i+start, start, end) ;
		icycleLength[ i ] = temp ;

		if ( temp > max )
			max = temp ;
	}

	return max ;
}

main()
{
	long start , end, retVal ;

	while ( cin >> start >> end )
	{
		retVal = calcyclelength(start, end) ;
		cout << start << " " << end << " " << retVal << endl ;
	}

	delete[] icycleLength ;
}