DY N DY

실력키우기 카드게임(C++) 본문

PARK/ALGORITHM

실력키우기 카드게임(C++)

손세지 2016. 5. 22. 12:55

1311 : 카드게임

제한시간: 1ms    메모리제한: 32MB
해결횟수: 359회    시도횟수: 1189회   



근우는 오늘 재미있는 카드 게임을 배우고 있다. 카드는 빨간색, 파란색, 노란색, 녹색의 네 가지 색이 있고, 색깔별로 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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
/**************************************************************
    Problem: 1311
    User: a132034
    Language: C++
    Result: Success
    Time:1 ms
    Memory:1740 kb
****************************************************************/
 
 
#include    <iostream>
#include    <algorithm>
using namespace std;
 
int main()
{
 
    char color[5];
    int num[5];
    bool rule[9];
 
    for (int i = 0; i < 5; ++i)
    {
        cin >> color[i] >> num[i];
    }
 
    //사실 점수를 결정하는데 번호와 색 간에 상관관계가 크게 없으므로 처음부터 정렬해둠.
    sort(num, num + 5);
 
    //1번 규칙 [모든 카드가 동일한 색 - 연속된 숫자일 때]
    rule[0] = true;
    for (int i = 1; i < 5; ++i)
    {
        if (color[0] != color[i])
            rule[0] = false;
    }
 
    int min = num[0];
    for (int i = 1; i < 5; ++i)
    {
        if (num[i] != min + i)
            rule[0] = false;
    }
 
    if (rule[0])
    {
        cout << *max_element(num, num + 5) + 900;
        return 0;
    }
     
    //2번 규칙 [5장 중 4장의 숫자가 같을 때]
    rule[1] = false;
 
    if (num[1] == num[4] || num[3] == num[0])
        rule[1] = true;
 
    if (rule[1])
    {
        cout << num[2] + 800;
        return 0;
    }
 
    //3번 규칙 [5장 중 3장, 2장이 각각 숫자가 같을 때]
    rule[2] = false;
    min = num[0];
    int max = num[4];
    int count1 = 0, count2 = 0;
    int res;
    for (int i = 0; i < 5; ++i)
    {
        if (num[i] == min)
            count1++;
        if (num[i] == max)
            count2++;
    }
 
    if ((count1 == 2 && count2 == 3))
    {
        rule[2] = true;
        res = max * 10 + min;
    }
     
    if ((count1 == 3 && count2 == 2))
    {
        rule[2] = true;
        res = min * 10 + max;
    }
 
    if (rule[2])
    {
        cout << res + 700;
        return 0;
    }
 
    //4번 규칙 [5장의 카드 색깔이 모두 같을 때]
    rule[3] = true;
 
    for (int i = 1; i < 5; ++i)
    {
        if (color[0] != color[i])
            rule[3] = false;
    }
 
    if (rule[3])
    {
        cout << *max_element(num, num + 5) + 600;
        return 0;
    }
 
    //5번 규칙 [숫자가 연속적일 때]
    rule[4] = true;
 
    min = num[0];
    for (int i = 1; i < 5; ++i)
    {
        if (num[i] != min + i)
            rule[4] = false;
    }
 
    if (rule[4])
    {
        cout << *max_element(num, num + 5) + 500;
        return 0;
    }
 
    //6번 규칙 [3장의 숫자가 동일할 때]
    rule[5] = false;
    int count = 0;
    int mid = num[2];
    for (int i = 0; i < 5; ++i)
    {
        if (num[i] == mid)
            count++;
    }
    if (count == 3)
        rule[5] = true;
 
    if (rule[5])
    {
        cout << mid + 400;
        return 0;
    }
 
    //7번 규칙 [2장의 숫자가 동일하고 또 다른 2장의 숫자가 동일할 때
    rule[6] = false;
     
    if ((num[0] == num[1]) && (num[2] == num[3]))
    {
        rule[6] = true;
    }
         
 
    if ((num[0] == num[1]) && (num[3] == num[4]))
    {
        rule[6] = true;
    }
 
    if ((num[1] == num[2]) && (num[3] == num[4]))
    {
        rule[6] = true;
    }
 
    res = num[3] * 10 + num[1];
 
    if (rule[6])
    {
        cout << res + 300;
        return 0;
    }
 
 
    //8번 규칙 [2장의 숫자가 동일할 때]
    rule[7] = false;
 
    int eq;
    for (int i = 0; i < 4; ++i)
    {
        if (num[i] == num[i + 1])
        {
            rule[7] = true;
            eq = num[i];
        }
    }
 
    if (rule[7])
    {
        cout << eq + 200;
        return 0;
    }
 
    //9번 규칙 [어떤 경우에도 해당하지 않을 때]
    cout << *max_element(num, num + 5) + 100;
 
    return 0;
}


맨 처음에는 점수를 결정하는데에 색-숫자 의 연관관계가 있는줄 알고 

max_element 함수를 사용했다가. 


색상 따로, 숫자 따로 보면서 점수를 계산해도 전혀 상관없다는것을 알고 아에 처음 받자마자 숫자를 정렬하였다.

규칙은 나와있는 그대로 하나씩 체크하면서 해당하는 경우 점수를 출력하고 종료하였다. 

사실 bool 변수를 꼭 사용할 필요는 없었지만 보기 편하게 하려고 사용하였다. 


그외 특별한 점은 없고 사용한 주요 함수는

sort, max_element 함수인데 사실 max_element는 별로 사용할 필요가 없다..

둘다 인수로 시작지점의 주소, 끝 지점의 주소를 주면

sort는 정렬(작은 수 부터), max_element는 가장 큰 수의 주소를 리턴한다. 

(다른 사용방법도 많지만 여기에서는 이렇게 사용했다.)