1. ๋ฌธ์ ์ค๋ช
์์๊ฐ ์ซ์ 3๊ฐ๋ฅผ ๋จธ๋ฆฟ์์ผ๋ก ์๊ฐ, ๋ฏผํ์ด๋ ๊ทธ ์ซ์๋ฅผ ๋ง์ถ๊ธฐ ์ํด 3๊ฐ์ ์๋ฅผ ๋งํ์ฌ N๋ฒ ์ถ์ธก์ ํ๋ค.
๋ฏผํ์ด๊ฐ ๋งํ ์ซ์ ์ค ํ๋๊ฐ ์์๊ฐ ์๊ฐํ ์ซ์์ ์์น๋ ๊ฐ๊ณ , ์ซ์๋ ๊ฐ์ผ๋ฉด 1 Strike,
๋ฏผํ์ด๊ฐ ๋งํ ์ซ์ ์ค ํ๋๊ฐ ์์๊ฐ ์๊ฐํ ์ซ์์ ์์น๋ ๋ค๋ฅด์ง๋ง, ์ซ์๋ ๊ฐ์ผ๋ฉด 1ball,
์ด ํ์๋ฅผ N๋ฒ ๋ฐ๋ณตํ ๋, ์์๊ฐ ์๊ฐํ ์ซ์ 3๊ฐ๊ฐ ๋ ์ ์๋ ํ๋ณด ์์ ๊ฐ์๋ฅผ ๊ตฌํ์ฌ๋ผ
2. ๋ฌธ์ ํธ๋ ์๋ฆฌ
๋ฏผํ์ด๊ฐ ์ถ์ธกํ ์ซ์๊ฐ ์์์ ๋จธ๋ฆฟ์ ์ซ์์ ์ผ๋ง๋ ๊ฐ์์ง๋, ํด๋น ์ซ์๊ฐ ๋ฐ์ ball_count๋ฅผ ๋ณด๋ฉด ๋๋ค.
์์์์, ์์๊ฐ ์๊ฐํ ์ซ์๊ฐ 324์ด๊ณ , ๋ฏผํ์ด๊ฐ ์ถ์ธกํ ์๊ฐ 429์ด๋ฉด 1S 1B์ด๋ค. ๋ฐ๋ผ์ ๋ฏผํ์ด๊ฐ ๋งํ ์ซ์ N ๊ฐ์ Ball_cnt๋ฅผ ๋ชจ๋ ์ถฉ์กฑํ๋ ์๋ผ๋ฉด, ์์๊ฐ ์๊ฐํ ์ซ์๊ฐ ๋ ์ ์๋ ํ๋ณด๊ตฐ์ผ๋ก์ ์๊ฒฉ์ ์ถฉ์กฑํ๋ค.
๋ฌธ์ ํธ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
- 123 ๋ถํฐ 789๊น์ง ๋ชจ๋ ์ซ์๋ฅผ ํ์ธํ๋ค. ํ์ฌ ํ์ธํ๋ ์์ ์ด๋ฆ์ K๋ผ๊ณ ํ์
(์๋ฆฟ์๊ฐ 3๊ฐ์ด๋ฏ๋ก ๋ธ๋ฃจํธํฌ์ค๋ก ํ๋ฆฌ๋ ๋ฌธ์ ์ด๋ค.) - K์ ๊ตฌ์ฑ์์ผ๋ก 0์ด ๋ค์ด์๊ฑฐ๋, ๊ฐ ์๋ฆฟ์์ ์ซ์๊ฐ ๊ฐ์ ๊ฒฝ์ฐ๋ ์ ์ธํ๋ค. (๋ฌธ์ ์ ์กฐ๊ฑด๊ณผ ๋ง์ง ์๋ค.)
- ์คํธ๋ผ์ดํฌ ์์ ๋ณผ ์๋ฅผ ์ฒดํฌํ๋ค.
- ๋ง์ฝ K๊ฐ ๋ฏผํ์ด์ ์ถ์ธก ์์ ๊ฐ์ผ๋ฉด ๋ฏผํ์ด๊ฐ ์ถ์ธกํ ๋ค์ ์๋ก ๋์ด๊ฐ๋ค.
๋ง์ฝ ํ๋ฆฌ๋ฉด K + 1ํ ์๋ฅผ ์ฒดํฌํ๋ค. - ๋ง์ฝ ๋ฏผํ์ด์ ์ถ์ธก ์ N๊ฐ ๋ชจ๋๋ฅผ K๊ฐ ํต๊ณผํ๋ฉด, K๋ ์์์ ๋จธ๋ฆฟ ์ ์ซ์๊ฐ ๋ ์ ์๋ ์๊ฒฉ์ด ์๋ค.
๋ฐ๋ผ์ candidate_cnt์ ์๋ฅผ ํ๋ ์ฌ๋ฆฐ๋ค.
3. ์ฝ๋ ๋ถ์
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
/*
* ์ซ์ ์ผ๊ตฌ 2503
* 1) ๋ฏผํ์ด๊ฐ ๋ฌผ์ด๋ณธ ์ซ์์ ๋ณผ ์นด์ดํธ๊ฐ ์ผ์นํ๋ฉด, ์ด์ฉ๋ฉด 3S๊ฐ ๊ฐ๋ฅํ ์ซ์์ด๋ค.
* 2) ๋ฏผํ์ด๊ฐ ๋ฌผ์ด๋ณธ ์ซ์์ ๋ณผ ์นด์ดํธ๊ฐ ๋ชจ๋ ์ผ์นํ๋ ์์ ๊ฐ์๋ฅผ ์ผ๋ค.
* */
public class Main {
// ** ํ
์คํธ ๊ฐ์
static int N;
// ** Ball Count ๋ฐฐ์ด, + ๊ทธ ๋์ ๊ฐ๋ค ๋ฐฐ์ด๋ก ์ ์ฅ
static char [][] guess;
static int [] strike;
static int [] ball;
// ** 3S์ ํ๋ณด๊ฐ ๋ ์ ์๋ ๊ฐ์ ๊ฐ์
static int candidate_cnt = 0;
static int [] now= new int[3];
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 1) ๊ฐ ์
๋ ฅ ๋ฐ๊ธฐ
N = Integer.parseInt(br.readLine());
guess = new char [N][3];
strike = new int[N];
ball = new int [N];
for (int i = 0; i < N; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
String s = st.nextToken();
// 1-1) ๊ฐ ํ๋ํ๋ ๋ถํดํด์ ๋ฃ๊ธฐ
guess[i][0] = s.charAt(0);
guess[i][1] = s.charAt(1);
guess[i][2] = s.charAt(2);
// 1-2) ๋ณผ ์นด์ดํธ ๋ฃ๊ธฐ
strike[i] = Integer.parseInt(st.nextToken());
ball[i] = Integer.parseInt(st.nextToken());
}
// 2) ์ซ์ ์ผ๊ตฌ์์ ๋์ฌ ์ ์๋ ๋ชจ๋ ์๋ฅผ ๊ฐ์ง๊ณ Guess[j]์ ๋น๊ตํ๋ฉฐ ๋ณผ ์นด์ดํธ๊ฐ ์ผ์นํ๋ฉด ๋ค์ ๋จ๊ณ๋ก ๋์ด๊ฐ๊ธฐ.
// ์๋๋ฉด Return ํ ๋ค์ ๊ป๋ก ๋ค์ ์๋
next_num: for (int i = 123; i < 988; i++) {
String temp = String.valueOf(i);
// 0์ ์กด์ฌํ์ง ์๋ ์์ด๋ฏ๋ก ์ ํจ์ฑ ๋ฐ๋ก ํ๋ฝ
if(temp.charAt(0) == '0' || temp.charAt(1) == '0' || temp.charAt(2) == '0'){
continue ;
}
if( temp.charAt(0) == temp.charAt(1) || temp.charAt(0) == temp.charAt(2) || temp.charAt(1) == temp.charAt(2)){
continue;
}
// 2-1) ์ ํจ์ฑ ์ฒดํฌ
for (int j = 0; j < N; j++) {
// a - ์ผ์น ํ์ธ
int strike_cnt = 0; int bal_cnt = 0;
// b - ๋ฏผํ์ด๊ฐ ์ถ์ธกํ ๊ฐ๊ณผ ๋น๊ตํ์ฌ ํด๋น ์์ ์ด ์คํธ๋ผ์ดํฌ ๋ณผ ์นด์ดํธ ํ์ธ
outerLoop: for (int k = 0; k < 3; k++) {
// ์คํธ๋ผ์ดํฌ ํ์ธ -> ๋ ์๊ฐ ์ผ์นํ๋ฉด ๋ฐ๋ก ๋ค์ ์ ์ฒดํฌ
if(guess[j][k] == temp.charAt(k)){
strike_cnt++;
continue;
}
// ์คํธ๋ผ์ดํฌ๊ฐ ์๋๋ผ๋ฉด ๋ณผ ์นด์ดํธ๋ก๋ ๋ง๋์ง ํ์ธ -> ball ์ธ๊ฒ ํ์ธ๋๋ฉด ๋ฐ๋ก ๋ค์ ์ ์ฒดํฌ
for (int l = 0; l < 3; l++) {
if(guess[j][k] == temp.charAt(l) && k != l){
bal_cnt++;
continue outerLoop;
}
}
}
// ์คํธ๋ผ์ดํฌ ๊ฐ์๊ฐ ๋ง์ง ์์ผ๋ฉด ์ ํจํ์ง ์์ผ๋ฏ๋ก ๊ทธ ๋ค์ ์๋ฅผ ์ฒดํฌํ๋ค.
if(strike_cnt != strike[j]){
continue next_num;
}
// ๋ณผ ๊ฐ์๊ฐ ๋ง์ง ์์ผ๋ฉด ์ ํจํ์ง ์์ผ๋ฏ๋ก ๊ทธ ๋ค์ ์๋ฅผ ์ฒดํฌํ๋ค.
if(bal_cnt != ball[j]){
continue next_num;
}
}
// 2-2) ์ด ์์น๊น์ง Continue ๊ฑฐ์น์ง ์๊ณ ์๋ค๋ ๊ฒ์ N๊ฐ์ ์ ํจ์ฑ ๊ฒ์ฆ์ ๋ค ํต๊ณผํด๋ธ ์ ํจํ ์๋ผ๋ ๋ป์ด๋ค.
candidate_cnt++;
}
System.out.println(candidate_cnt);
}
}
4. ์๊ฒฐ
๋ฌธ์ ๊ฐ ์ ํ๋ ค์ ๋ต์ง๋ฅผ ๋ดค๋ค. ๊ตฌํ ๋ฅ๋ ฅ์ด ๋ง์ด ๋ถ์กฑํ๋ค. ๋ง์ด ํ์ด์ ์ฑ์์ผ๊ฒ ๋ค.