JUNGOL 실력키우기 1311 : 카드게임

근우는 오늘 재미있는 카드 게임을 배우고 있다. 카드는 빨간색, 파란색, 노란색, 녹색의 네 가지 색이 있고, 색깔별로 1부터 9까지 숫자가 쓰여진 카드가 9장씩 있다. 카드는 모두 36(=4x9)장이다. 근우가 배운 카드 게임은 36장의 카드에서 5장을 뽑고, 아래와 같은 규칙으로 정수를 계산하는 것이다.

 

각 카드는 다음과 같이 나타낸다. 카드의 색깔은 영어 대문자 R, B, Y, G로 나타내는데, R은 빨간색, B는 파란색, Y는 노란색, G는 녹색을 뜻한다. 예를 들어서 Y8은 노란색 8을 나타내고, B5는 파란색 5를 나타낸다.

 

<점수를 정하는 규칙>
① 카드 5장이 모두 같은 색이면서 숫자가 연속적일 때, 점수는 가장 높은 숫자에 900을 더한다. 예를 들어, 카드가 Y4, Y3, Y2, Y5, Y6 일 때 점수는 906(=6+900)점이다.

② 카드 5장 중 4장의 숫자가 같을 때 점수는 같은 숫자에 800을 더한다. 예를 들어, 카드가 B3, R3, B7, Y3, G3 일 때 점수는 803(=3+800)점이다.

③ 카드 5장 중 3장의 숫자가 같고 나머지 2장도 숫자가 같을 때 점수는 3장이 같은 숫자에 10을 곱하고 2장이 같은 숫자를 더한 다음 700을 더한다. 예를 들어, 카드가 R5, Y5, G7, B5, Y7 일 때 점수는 757(=5x10+7+700)점이다.

④ 5장의 카드 색깔이 모두 같을 때 점수는 가장 높은 숫자에 600을 더한다. 예를 들어, 카드가 Y3, Y4, Y8, Y6, Y7 일 때 점수는 608(=8+600)점이다.

⑤ 카드 5장의 숫자가 연속적일 때 점수는 가장 높은 숫자에 500을 더한다. 예를 들어 R7, R8, G9, Y6, B5 일 때 점수는 509(=9+500)점이다.

⑥ 카드 5장 중 3장의 숫자가 같을 때 점수는 같은 숫자에 400을 더한다. 예를 들어 R7, Y7, R2, G7, R5 일 때 점수는 407(=7+400)점이다.

⑦ 카드 5장 중 2장의 숫자가 같고 또 다른 2장의 숫자가 같을 때 점수는 같은 숫자 중 큰 숫자에 10을 곱하고 같은 숫자 중 작은 숫자를 더한 다음 300을 더한다. 예를 들어, R5, Y5, Y4, G9, B4 일 때 점수는 354(=5X10+4+300)점이다.

⑧ 카드 5장 중 2장의 숫자가 같을 때 점수는 같은 숫자에 200을 더한다. 예를 들어, R5, Y2, B5, B3, G4 일 때 점수는 205(=5+200)점이다.

⑨ 위의 어떤 경우에도 해당하지 않을 때 점수는 가장 큰 숫자에 100을 더한다. 예를 들어, R1, R2, B4, B8, Y5 일 때 점수는 108(=8+100)점이다.

 

입력으로 카드 5장이 주어질 때, 카드 게임의 점수를 구하는 프로그램을 작성하시오. 두 가지 이상의 규칙을 적용할 수 있는 경우에는 가장 높은 점수가 카드 게임의 점수이다.

 

첫째 줄부터 다섯째 줄까지 한 줄에 카드 하나씩 입력된다.
카드의 색깔과 숫자 사이에는 빈 칸이 하나 있다.

 

한 줄에 카드의 점수를 출력한다.

[Copy] B 3 B 7 R 1 B 2 Y 7

[Copy] 207

---

흠.. .가끔 가다 보면 이게 돌아가야 하는데 안돌아가는 경우가 꽤 있다.

도대체 컴파일러 버전이 얼마나 오래된 거면 C++11 기능이 안돌아가는거야 젠장

이럴 때는  진짜 하기 싫어진다...

일단 내 PC에서는 잘 돌아가니 코드는 올리겠으나 현재 JUNGOL측에서는 돌아가지 않으므로 다른 사람들 코드를 참고해서 만들어 봐야겠다.

2017-08-22 수정)

오늘 다른 블로그를 찾아보니 점수를 계산하는데 번호와 색간에 상관관계가 없다는 것을 보고 새로 짜고 JUNGOL홈페이지에서 제대로 돌아가는 것 확인했습니다. 좀더 알아보기 쉽게 짜려고 했는데 어쩌다보니 복잡해 보이는 것 같네요. 조금 더 노력해야할 것 같습니다.

#include <iostream>
#include <map>
#include <set>
#include <functional>
 
using namespace std;
 
typedef char color;
typedef int number;
typedef int counter;
 
typedef map<color, counter> colorMap;
typedef map<number, counter, greater<number>> numberMap;
typedef multimap<counter, number, greater<counter>> counterMap;
typedef multiset<number> numberSet;
 
 
enum SAME_NUMBER { FOUR, THREE_TWO, THREE, TWO_TWO, TWO, NONE };
 
bool IsSequence(numberSet& sequenceChecker);
bool IsAllSameColor(colorMap& colorChecker);
SAME_NUMBER HowManySame(numberMap& numberChecker);
int GetScoreRank(numberSet& sequenceChecker, colorMap& colorChecker, numberMap& numberChecker);
int MakeScoreByScoreRank(numberMap& numberChecker, int scoreRank);
 
int main(void)
{
    color col;
    number num;
    int scoreRank;
 
    colorMap colorChecker;
    numberMap numberChecker;
    numberSet sequenceChecker;
 
    for (int i = 0; i < 5; ++i)
    {
        cin >> col >> num;
 
        colorChecker[col]++;
        numberChecker[num]++;
        sequenceChecker.insert(num);
    }
 
    scoreRank = GetScoreRank(sequenceChecker, colorChecker, numberChecker);
 
    cout << MakeScoreByScoreRank(numberChecker, scoreRank) << endl;
}
 
bool IsSequence(numberSet& sequenceChecker)
{
    for (auto& num = sequenceChecker.begin(); num != sequenceChecker.end(); ++num)
    {
        if (next(num) == sequenceChecker.end()) break;
        if (*num + 1 != *next(num)) return false;
    }
    return true;
}
 
bool IsAllSameColor(colorMap& colorChecker)
{
    return colorChecker.size() == 1;
}
 
SAME_NUMBER HowManySame(numberMap& numberChecker)
{
    counterMap sorter;
    for (auto& data : numberChecker)
    {
        sorter.insert(make_pair(data.second, data.first));
    }
    if ((*sorter.begin()).first == 4) return FOUR;
    if ((*sorter.begin()).first == 3)
    {
        if ((*next(sorter.begin())).first == 2) return THREE_TWO;
        return THREE;
    }
    if ((*sorter.begin()).first == 2)
    {
        if ((*next(sorter.begin())).first == 2) return TWO_TWO;
        return TWO;
    }
    return NONE;
}
 
int GetScoreRank(numberSet& sequenceChecker, colorMap& colorChecker, numberMap& numberChecker)
{
    int scoreRank = 9;
 
    if (IsSequence(sequenceChecker))
    {
        scoreRank = 5;
    }
    if (IsAllSameColor(colorChecker))
    {
        if (scoreRank == 5) return 1;
        scoreRank = 4;
    }
    switch (HowManySame(numberChecker))
    {
    case FOUR:
            return 2;
    case THREE_TWO:
            return 3;
    case THREE:
        if (scoreRank == 9)
            scoreRank = 6;
        break;
    case TWO_TWO:
        if (scoreRank == 9)
            scoreRank = 7;
        break;
    case TWO:
        if (scoreRank == 9)
            scoreRank = 8;
        break;
    }
 
    return scoreRank;
}
 
int MakeScoreByScoreRank(numberMap& numberChecker, int scoreRank)
{
    counterMap sorter;
    for (auto& data : numberChecker)
    {
        sorter.insert(make_pair(data.second, data.first));
    }
 
    if (scoreRank == 1) return 900 + (*numberChecker.begin()).first;
    if (scoreRank == 2) return 800 + (*sorter.begin()).second;
    if (scoreRank == 3) return 700 + (*sorter.begin()).second * 10 + (*next(sorter.begin())).second;
    if (scoreRank == 4) return 600 + (*numberChecker.begin()).first;
    if (scoreRank == 5) return 500 + (*numberChecker.begin()).first;
    if (scoreRank == 6) return 400 + (*sorter.begin()).second;
    if (scoreRank == 7) return ((*sorter.begin()).second>(*next(sorter.begin())).second)?
        300 + (*sorter.begin()).second * 10 + (*next(sorter.begin())).second
        : 300 + (*next(sorter.begin())).second * 10 + (*sorter.begin()).second;
    if (scoreRank == 8) return 200 + (*sorter.begin()).second;
    return 100 + (*numberChecker.begin()).first;
}

#include <iostream>
#include <algorithm>
#include <functional>
#include <array>
#include <map>
 
using namespace std;
 
enum class SAME_CARD { FOUR, THREE_TWO, THREE, TWO_TWO, TWO, NONE };
 
bool IsAllSameColor(array<char, 5>& colors);
bool IsSequence(array<int, 5>& numbers);
array<int, 2> GetSameCardKind(array<int, 5>& numbers);
SAME_CARD GetSameCard(array<int, 5>& numbers);
int GetCardRanking(array<char, 5>& colors, array<int, 5>& numbers);
int GetScore(array<char, 5>& colors, array<int, 5>& numbers);
 
int main(void)
{
    array<char, 5> colors;
    array<int, 5> numbers;
 
    for (int i = 0; i < 5; ++i)
    {
        cin >> colors[i] >> numbers[i];
    }
    // 이후 연속 판별 및 동일 카드 판별을 위해 오름차순 정렬
    sort(numbers.begin(), numbers.end());
 
    cout << GetScore(colors, numbers) << endl;
}
 
// 모든 색상이 같은지 판별하는 함수
bool IsAllSameColor(array<char, 5>& colors)
{
    char first = colors[0];
 
    for (int i = 1; i < 5; ++i)
    {
        if (colors[i] != first)
            return false;
    }
    return true;
}
 
// 카드가 연속적인지 판별하는 함수
bool IsSequence(array<int, 5>& numbers)
{
    int first = numbers[0];
    for (int i = 0; i < 5; ++i)
    {
        if (numbers[i] != first++)
            return false;
    }
    return true;
}
 
// 같은 카드의 개수를 파악하는 함수
array<int, 2> GetSameCardCount(array<int, 5>& numbers)
{
    map<int, int> sameCounter;
    multimap<int, int, greater<int>> countChecker;
    array<int, 2> sameChecker;
 
    for (int i = 0; i < 5; ++i)
    {
        sameCounter[numbers[i]]++;
    }
 
    for (auto& temp : sameCounter)
    {
        countChecker.emplace(make_pair(temp.second, temp.first));
    }
 
    // 동일한 카드의 개수를 파악한다.
    // 가장 많이 동일한 상위 2가지의 개수를 파악한다.
    int cnt = 0;
    for (auto& temp : countChecker)
    {
        sameChecker[cnt++] = temp.first;
        if (cnt > 1) break;
    }
 
    return sameChecker;
}
 
// 같은 카드의 종류를 파악하는 함수
array<int, 2> GetSameCardKind(array<int, 5>& numbers)
{
    map<int, int> sameCounter;
    array<int, 2> sameChecker = GetSameCardCount(numbers);
    array<int, 2> sameNumbers;
 
    for (int i = 0; i < 5; ++i)
    {
        sameCounter[numbers[i]]++;
    }
 
    for (int i = 0; i < 2; ++i)
    {
        for (auto& m : sameCounter)
        {
            if (m.second == sameChecker[i])
            {
                sameNumbers[i] = m.first;
                sameCounter.erase(m.first);
                break;
            }
        }
    }
 
    return sameNumbers;
}
 
// 같은 카드의 개수의 종류를 파악하는 함수
SAME_CARD GetSameCard(array<int, 5>& numbers)
{
    array<int, 2> sameChecker = GetSameCardCount(numbers);
 
    if (sameChecker[0] >= 4) return SAME_CARD::FOUR;
    if (sameChecker[0] == 3 && sameChecker[1] == 2) return SAME_CARD::THREE_TWO;
    if (sameChecker[0] == 3) return SAME_CARD::THREE;
    if (sameChecker[0] == 2 && sameChecker[1] == 2) return SAME_CARD::TWO_TWO;
    if (sameChecker[0] == 2) return SAME_CARD::TWO;
    return SAME_CARD::NONE;
}
 
// 점수를 낼 카드의 랭킹을 파악하는 함수
int GetCardRanking(array<char, 5>& colors, array<int, 5>& numbers)
{
    bool sameChecker = IsAllSameColor(colors);
    bool sequenceChecker = IsSequence(numbers);
    SAME_CARD cardCounter = GetSameCard(numbers);
 
    if (sameChecker && sequenceChecker) return 1;
    if (cardCounter == SAME_CARD::FOUR) return 2;
    if (cardCounter == SAME_CARD::THREE_TWO) return 3;
    if (sameChecker) return 4;
    if (sequenceChecker) return 5;
    if (cardCounter == SAME_CARD::THREE) return 6;
    if (cardCounter == SAME_CARD::TWO_TWO) return 7;
    if (cardCounter == SAME_CARD::TWO) return 8;
    return 9;
}
 
// 점수를 리턴해주는 함수
int GetScore(array<char, 5>& colors, array<int, 5>& numbers)
{
    int ranking = GetCardRanking(colors, numbers);
    int maxNumber = numbers[4];
    array<int, 2> sameNumbers = GetSameCardKind(numbers);
 
    if (ranking == 1) return 900 + maxNumber;
    if (ranking == 2) return 800 + sameNumbers[0];
    if (ranking == 3) return 700 + sameNumbers[0] * 10 + sameNumbers[1];
    if (ranking == 4) return 600 + maxNumber;
    if (ranking == 5) return 500 + maxNumber;
    if (ranking == 6) return 400 + sameNumbers[0];
    if (ranking == 7) return 300 + (sameNumbers[0] > sameNumbers[1]?
        sameNumbers[0] * 10  + sameNumbers[1]:
        sameNumbers[1] * 10 + sameNumbers[0]);
    if (ranking == 8) return 200 + sameNumbers[0];
    return 100 + maxNumber;
}

JUNGOL) 문제은행) 실력키우기) 카드게임