https://school.programmers.co.kr/learn/courses/30/lessons/42839
๋ฌธ์ ์ค๋ช
ํ์๋ฆฌ ์ซ์๊ฐ ์ ํ ์ข ์ด ์กฐ๊ฐ์ด ํฉ์ด์ ธ์์ต๋๋ค. ํฉ์ด์ง ์ข ์ด ์กฐ๊ฐ์ ๋ถ์ฌ ์์๋ฅผ ๋ช ๊ฐ ๋ง๋ค ์ ์๋์ง ์์๋ด๋ ค ํฉ๋๋ค.
๊ฐ ์ข ์ด ์กฐ๊ฐ์ ์ ํ ์ซ์๊ฐ ์ ํ ๋ฌธ์์ด numbers๊ฐ ์ฃผ์ด์ก์ ๋, ์ข ์ด ์กฐ๊ฐ์ผ๋ก ๋ง๋ค ์ ์๋ ์์๊ฐ ๋ช ๊ฐ์ธ์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- numbers๋ ๊ธธ์ด 1 ์ด์ 7 ์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
- numbers๋ 0~9๊น์ง ์ซ์๋ง์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- "013"์ 0, 1, 3 ์ซ์๊ฐ ์ ํ ์ข ์ด ์กฐ๊ฐ์ด ํฉ์ด์ ธ์๋ค๋ ์๋ฏธ์ ๋๋ค.
์ ์ถ๋ ฅ ์
numbers | return |
"17" | 3 |
"011" | 2 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์์ #1
[1, 7]์ผ๋ก๋ ์์ [7, 17, 71]๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค.
์์ #2
[0, 1, 1]์ผ๋ก๋ ์์ [11, 101]๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค.
- 11๊ณผ 011์ ๊ฐ์ ์ซ์๋ก ์ทจ๊ธํฉ๋๋ค.
๋ด ํด๋ต
#include <string>
#include <vector>
#include <set>
#include <algorithm>
#include <math.h
using namespace std;
// ์์ ๊ฒ์ฌ
bool isPrime(int n)
{
// 2๋ฏธ๋ง ์์๋ ์๋ค.
if(n < 2)
return false;
// 2๋ถํฐ n์ ์ ๊ณฑ๊ทผ๊น์ง ์์ ๊ฒ์ฌ
for(int i = 2; i <= sqrt(n); ++i)
{
if(n%i == 0)
return false;
}
return true;
}
int solution(string numbers) {
int answer = 0;
set<int>ans{};
// ์
๋ ฅ ๋ฌธ์์ด ์ ๋ ฌ
sort(numbers.begin(), numbers.end());
// numbers ์์ด์ ์ฒซ๋ฒ์งธ ๋ฌธ์๋ถํฐ ๋ฌธ์๋ฅผ ๋์ ํด๊ฐ๋ฉฐ ์์์ธ์ง ๋น๊ตํ๋ค.
do
{
string tmp;
for(int i = 0; i < numbers.size(); ++i)
{
tmp += numbers[i];
if(isPrime(stoi(tmp)))
ans.insert(stoi(tmp)); // set์ด๋ฏ๋ก ์์์ธ ์ซ์ ์กฐํฉ๋ค์ ์ค๋ณต์์ด ๋ด๋๋ค.
}
}
while(next_permutation(numbers.begin(), numbers.end()));
answer = ans.size();
return answer;
}
์ด ๋ฌธ์ ๋ '์์ ํ๋ณ ํ๊ธฐ'์ '๋ฌธ์๋ฅผ ์กฐํฉํ์ฌ ์ซ์ ์ฐพ๊ธฐ' ๊ฐ ๊ด๊ฑด์ธ ๋ฌธ์ ์๋ค.
1. ์์ ํ๋ณํ๊ธฐ
์๋ฅผ ๋ค์ด 16์ด๋ผ๋ ์์ ์ฝ์๋ ๋ค์๊ณผ ๊ฐ๋ค.
- 1 X 16 = 16 _________
- 2 X 8 = 16 ___ |
- 4 X 4 = 16 | ๋์นญ ๋์นญ
- 8 X 2 = 16 ___ |
- 16 X 1 = 16 _________
๊ฐ์ด๋ฐ ์ฝ์ 4๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ฐ ๋ฑ์์ด ๋์นญ์ ์ธ ํํ๋ฅผ ๋ณด์ธ๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
์๋ฅผ ๋ค์ด 2 X 8 = 16์ 8 X 2 = 16๊ณผ ๋์นญ์ด๋ค.
๊ทธ๋ ๊ธฐ์ ํน์ ํ ์์ฐ์ X๊ฐ ์์์ธ์ง ํ์ธํ๊ธฐ ์ํ์ฌ ๋ฐ๋ก ๊ฐ์ด๋ฐ ์ฝ์๊น์ง๋ง ๋๋์ด ๋จ์ด์ง๋์ง ํ์ธํ๋ฉด ๋๋ค.
๋ค์ ๋งํด ์ ๊ณฑ๊ทผ๊น์ง๋ง(๊ฐ์ด๋ฐ ์ฝ์๊น์ง๋ง) ํ์ธํ๋ฉด ๋๋ค!!
2. ๋ฌธ์๋ฅผ ์กฐํฉํ์ฌ ์ซ์ ์ฐพ๊ธฐ
algorithm ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ next_permutation ์ด๋ผ๋ ํจ์๋ฅผ ์ ์ฌ์ฉํ๋ฉด ์ฝ๊ฒ ํด๊ฒฐํ ์ ์๋ค.
- next_permutation ์ด๋?
bool next_permutation (BidirectionalIterator first, BidirectionalIterator last);
next_permutation ํจ์์ ๋ฒกํฐ์ iterator ํน์ ๋ฐฐ์ด์ ์ฃผ์๋ฅผ ๋ฃ์ผ๋ฉด ๋ค์ ์์ด(1-2-3-4์ ๋ค์ ์์ด์ 1-2-4-3)์ ๊ฒฐ๊ณผ๊ฐ ๋ฒกํฐ๋ ๋ฐฐ์ด์ ์ ์ฉ๋๋ค.
- next_permutation ์ ๋ฐํ๊ฐ
์ฑ๊ณต์ ์ผ๋ก ์์ด์ ์์ฑํ๋ค๋ฉด true๋ฅผ ๋ฐํํ๊ณ
๋ชจ๋ ์์ด์ ์์ฑํด ๋ค์ ์์ด์ด ์๋ค๋ฉด false๋ฅผ ๋ฐํํ๋ค.
'๐ฅ๏ธ Study Note > Coding Test' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๋ก๊ทธ๋๋จธ์ค / level.2 / ํผ๋ก๋(C++) (0) | 2023.04.01 |
---|---|
ํ๋ก๊ทธ๋๋จธ์ค / level.2 / ์นดํซ(C++) (0) | 2023.03.30 |
ํ๋ก๊ทธ๋๋จธ์ค / level.1 / ๋ชจ์๊ณ ์ฌ(C++) (0) | 2023.03.27 |
ํ๋ก๊ทธ๋๋จธ์ค / level.1 / ์ต์์ง์ฌ๊ฐํ(C++) (0) | 2023.03.27 |
ํ๋ก๊ทธ๋๋จธ์ค / level.2 / H-Index(C++) (0) | 2023.03.24 |