๋ฌธ์
<๋ฌธ์ ์ค๋ช >
ํ์๋ฆฌ ์ซ์๊ฐ ์ ํ ์ข ์ด ์กฐ๊ฐ์ด ํฉ์ด์ ธ์์ต๋๋ค. ํฉ์ด์ง ์ข ์ด ์กฐ๊ฐ์ ๋ถ์ฌ ์์๋ฅผ ๋ช ๊ฐ ๋ง๋ค ์ ์๋์ง ์์๋ด๋ ค ํฉ๋๋ค.
๊ฐ ์ข ์ด ์กฐ๊ฐ์ ์ ํ ์ซ์๊ฐ ์ ํ ๋ฌธ์์ด numbers๊ฐ ์ฃผ์ด์ก์ ๋, ์ข ์ด ์กฐ๊ฐ์ผ๋ก ๋ง๋ค ์ ์๋ ์์๊ฐ ๋ช ๊ฐ์ธ์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
<์ ํ์ฌํญ>
- numbers๋ ๊ธธ์ด 1 ์ด์ 7 ์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
- numbers๋ 0~9๊น์ง ์ซ์๋ง์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- 013์ 0, 1, 3 ์ซ์๊ฐ ์ ํ ์ข ์ด ์กฐ๊ฐ์ด ํฉ์ด์ ธ์๋ค๋ ์๋ฏธ์ ๋๋ค.
https://programmers.co.kr/learn/courses/30/lessons/42839
๋ฌธ์ ํ์ด
๋ค์์ ๋ฌธ์ ๋ฅผ ์์๋๋ก ํด๊ฒฐํด์ ๋ฌธ์ ๋ฅผ ํ์์ต๋๋ค.
1. ์ข ์ด ์กฐ๊ฐ์ผ๋ก ๋ง๋ค ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ๊ตฌํ๊ธฐ
2. ๋ชจ๋ ๊ฒฝ์ฐ์ ์์์ ์ค๋ณต๋ ์ ์ ๊ฑฐํ๊ธฐ
3. ๋จ์ ์ ์ค์์ ์์ ํ๋ณํ๊ธฐ
1. ์ข ์ด ์กฐ๊ฐ์ผ๋ก ๋ง๋ค ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ๊ตฌํ๊ธฐ
๊ฐ์ง๊ณ ์๋ ์ข ์ด ์กฐ๊ฐ์ ๋ชจ๋ ์์ด์ ๋ํด์, 1๋ถํฐ ์ข ์ด ์กฐ๊ฐ์ ์๊น์ง์ ์กฐํฉ์ ๊ตฌํ์ต๋๋ค.
ex) numbers = "012"์ธ ๊ฒฝ์ฐ
์์ด 1) "012"
"0", "01", "012" ์ ์ฅ
์์ด 2) "021"
"0", "02", "021" ์ ์ฅ
.
.
.
์์ด 6) "210"
"2", "21", "210" ์ ์ฅ
2. ๋ชจ๋ ๊ฒฝ์ฐ์ ์์์ ์ค๋ณต๋ ์ ์ ๊ฑฐํ๊ธฐ
1๊ณผ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ ๊ฒฝ์ฐ, "02"์ "2"์ ์ฌ์ค 2์ด๋ผ๋ ๊ฐ์ ์์ ๋๋ค. ๋ฐ๋ผ์ vector ๋ด์ ์ค๋ณต์ ์์ ๊ธฐ ์ํด erase์ unique๋ฅผ ์ฌ์ฉํ์ต๋๋ค.
vector<int> v = { 1, 2, 3, 1, 2 };
sort(v.begin(), v.end()); // 11223
unique(v.begin(), v.end()); // 12323
์์ ๊ฐ์ด ์ ๋ ฌ๋ ๋ฒกํฐ์์ unique๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด ์ค๋ณต๋์ง ์์ ๊ฐ์ ์์ชฝ์ผ๋ก ๋ณด๋ด๊ณ , ๋ค์ชฝ์๋ ์ฐ๋ ๊ธฐ ๊ฐ๋ค์ ์ ์ฅํ๊ฒ ๋ฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ unique๋ ์ ์ผ ์ฒ์ ๋์ค๋ ์ฐ๋ ๊ธฐ ๊ฐ์ iterator๋ฅผ ๋ฐํํฉ๋๋ค.(์ฌ๊ธฐ์ v[3], ์ฆ ๋ ๋ฒ์งธ ๋์ค๋ 2๋ฅผ ๊ฐ๋ฆฌํต๋๋ค.)
v.erase(unique(v.begin(), v.end()), v.end());
๋ฐ๋ผ์ ์์ ๊ฐ์ ์ฝ๋๋ฅผ ์์ฑํ๋ฉด, ๋ฒกํฐ์์ ํ์ ์๋ ๊ฐ๋ค์ ์ญ์ ํ๊ณ ์ค๋ณต ์๋ ๋ฐ์ดํฐ๋ฅผ ์ป์ ์ ์์ต๋๋ค.
3. ๋จ์ ์ ์ค์์ ์์ ํ๋ณํ๊ธฐ
์์๋ฅผ ํ๋ณํ๊ธฐ ์ํด ์๋ผํ ์คํ ๋ค์ค์ ์ฒด๋ฅผ ์ด์ฉํ์์ต๋๋ค. ์๋ผํ ์คํ ๋ค์ค์ ์ฒด๋ฅผ ๊ฐ๋จํ ์ค๋ช ํ์๋ฉด, 2๋ถํฐ n๊น์ง์ ์ ์ค์ ์์๋ฅผ ํ๋ณํ๊ธฐ ์ํ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ๊ฐ๋จํ๊ฒ ์ค๋ช ํ์๋ฉด, ์์๋ฅผ ์ฐพ์ผ๋ฉด ํด๋น ์์ ๋ฐฐ์๋ฅผ ๋ชจ๋ ์ง์๋๊ฐ๋ ๋ฐฉ์์ ๋๋ค. ์์ธํ ์ค๋ช ์ ๋งํฌ์ ๋์์์ต๋๋ค.
์์ค์ฝ๋
// ์์ ์ฐพ๊ธฐ
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <math.h>
using namespace std;
// ์์ ํ๋ณ ํจ์
bool isPrime(int n) {
if (n < 2) return false;
// ์๋ผํ ์คํ
๋ค์ค์ ์ฒด
for (int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return false;
return true;
}
int solution(string numbers) {
int answer = 0;
vector<char> v; // ์ข
์ด ์กฐ๊ฐ์ ๊ฐ ์ซ์ ์ ์ฅ
vector<int> nums; // ์ข
์ด ์กฐ๊ฐ์ผ๋ก ๋ง๋ค ์ ์๋ ๋ชจ๋ ์ ์ ์ฅ
// numbers์ ๊ฐ ์ซ์๋ฅผ v์ ์
๋ ฅ ํ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
for (int i = 0; i < numbers.size(); i++)
v.push_back(numbers[i]);
sort(v.begin(), v.end());
do {
string temp = "";
// ๋ง๋ค ์ ์๋ ๋ชจ๋ ์ซ์ nums์ ์ ์ฅ
for (int i = 0; i < v.size(); i++) {
temp.push_back(v[i]);
nums.push_back(stoi(temp));
}
} while (next_permutation(v.begin(), v.end()));
// ์ค๋ณต ๊ฐ ์ง์ฐ๊ธฐ
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
for (int i = 0; i < nums.size(); i++)
// ์์์ผ ๊ฒฝ์ฐ answer++
if (isPrime(nums[i]))
answer++;
return answer;
}
๊ณต๋ถํ ๊ฒ์ ์ ๋ฆฌํ ๋ด์ฉ์ ๋๋ค. ์์ ํ ๋ถ๋ถ์ด ์๋ค๋ฉด ์๋ ค์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค :)
'Algorithm > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค / C++] ์นดํซ ํ์ด (0) | 2020.07.30 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค / C++] ์ซ์ ์ผ๊ตฌ ํ์ด (0) | 2020.07.30 |
[ํ๋ก๊ทธ๋๋จธ์ค / c++] ์ด์ค์ฐ์ ์์ํ ํ์ด (0) | 2020.07.29 |
[ํ๋ก๊ทธ๋๋จธ์ค / C++] ๋์คํฌ ์ปจํธ๋กค๋ฌ ํ์ด (0) | 2020.07.24 |
[ํ๋ก๊ทธ๋๋จธ์ค / C++] ๋ผ๋ฉด๊ณต์ฅ ํ์ด (0) | 2020.07.24 |