https://school.programmers.co.kr/learn/courses/30/lessons/17677
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์ ์ค๋ช
๋ด์ค ํด๋ฌ์คํฐ๋ง
์ฌ๋ฌ ์ธ๋ก ์ฌ์์ ์์์ง๋ ๋ด์ค, ํนํ ์๋ณด์ฑ ๋ด์ค๋ฅผ ๋ณด๋ฉด ๋น์ท๋น์ทํ ์ ๋ชฉ์ ๊ธฐ์ฌ๊ฐ ๋ง์ ์ ์ ํ์ํ ๊ธฐ์ฌ๋ฅผ ์ฐพ๊ธฐ๊ฐ ์ด๋ ต๋ค. Daum ๋ด์ค์ ๊ฐ๋ฐ ์ ๋ฌด๋ฅผ ๋งก๊ฒ ๋ ์ ์ ์ฌ์ ํ๋ธ๋ ์ฌ์ฉ์๋ค์ด ํธ๋ฆฌํ๊ฒ ๋ค์ํ ๋ด์ค๋ฅผ ์ฐพ์๋ณผ ์ ์๋๋ก ๋ฌธ์ ์ ์ ๊ฐ์ ํ๋ ์ ๋ฌด๋ฅผ ๋งก๊ฒ ๋์๋ค.
๊ฐ๋ฐ์ ๋ฐฉํฅ์ ์ก๊ธฐ ์ํด ํ๋ธ๋ ์ฐ์ ์ต๊ทผ ํ์ ๊ฐ ๋๊ณ ์๋ "์นด์นด์ค ์ ์ ๊ฐ๋ฐ์ ๊ณต์ฑ" ๊ด๋ จ ๊ธฐ์ฌ๋ฅผ ๊ฒ์ํด๋ณด์๋ค.
- ์นด์นด์ค ์ฒซ ๊ณต์ฑ..'๋ธ๋ผ์ธ๋' ๋ฐฉ์ ์ฑ์ฉ
- ์นด์นด์ค, ํฉ๋ณ ํ ์ฒซ ๊ณต์ฑ.. ๋ธ๋ผ์ธ๋ ์ ํ์ผ๋ก ๊ฐ๋ฐ์ ์ฑ์ฉ
- ์นด์นด์ค, ๋ธ๋ผ์ธ๋ ์ ํ์ผ๋ก ์ ์ ๊ฐ๋ฐ์ ๊ณต์ฑ
- ์นด์นด์ค ๊ณต์ฑ, ์ ์ ๊ฐ๋ฐ์ ์ฝ๋ฉ ๋ฅ๋ ฅ๋ง ๋ณธ๋ค
- ์นด์นด์ค, ์ ์ ๊ณต์ฑ.. "์ฝ๋ฉ ์ค๋ ฅ๋ง ๋ณธ๋ค"
- ์นด์นด์ค "์ฝ๋ฉ ๋ฅ๋ ฅ๋ง์ผ๋ก 2018 ์ ์ ๊ฐ๋ฐ์ ๋ฝ๋๋ค"
๊ธฐ์ฌ์ ์ ๋ชฉ์ ๊ธฐ์ค์ผ๋ก "๋ธ๋ผ์ธ๋ ์ ํ"์ ์ฃผ๋ชฉํ๋ ๊ธฐ์ฌ์ "์ฝ๋ฉ ํ ์คํธ"์ ์ฃผ๋ชฉํ๋ ๊ธฐ์ฌ๋ก ๋๋๋ ๊ฑธ ๋ฐ๊ฒฌํ๋ค. ํ๋ธ๋ ์ด๋ค์ ๊ฐ๊ฐ ๋ฌถ์ด์ ๋ณด์ฌ์ฃผ๋ฉด ์นด์นด์ค ๊ณต์ฑ ๊ด๋ จ ๊ธฐ์ฌ๋ฅผ ์ฐพ์๋ณด๋ ์ฌ์ฉ์์๊ฒ ์ ์ฉํ ๋ฏ์ถ์๋ค.
์ ์ฌํ ๊ธฐ์ฌ๋ฅผ ๋ฌถ๋ ๊ธฐ์ค์ ์ ํ๊ธฐ ์ํด์ ๋ ผ๋ฌธ๊ณผ ์๋ฃ๋ฅผ ์กฐ์ฌํ๋ ํ๋ธ๋ "์์นด๋ ์ ์ฌ๋"๋ผ๋ ๋ฐฉ๋ฒ์ ์ฐพ์๋๋ค.
์์นด๋ ์ ์ฌ๋๋ ์งํฉ ๊ฐ์ ์ ์ฌ๋๋ฅผ ๊ฒ์ฌํ๋ ์ฌ๋ฌ ๋ฐฉ๋ฒ ์ค์ ํ๋๋ก ์๋ ค์ ธ ์๋ค. ๋ ์งํฉ A, B ์ฌ์ด์ ์์นด๋ ์ ์ฌ๋ J(A, B)๋ ๋ ์งํฉ์ ๊ต์งํฉ ํฌ๊ธฐ๋ฅผ ๋ ์งํฉ์ ํฉ์งํฉ ํฌ๊ธฐ๋ก ๋๋ ๊ฐ์ผ๋ก ์ ์๋๋ค.
์๋ฅผ ๋ค์ด ์งํฉ A = {1, 2, 3}, ์งํฉ B = {2, 3, 4}๋ผ๊ณ ํ ๋, ๊ต์งํฉ A ∩ B = {2, 3}, ํฉ์งํฉ A ∪ B = {1, 2, 3, 4}์ด ๋๋ฏ๋ก, ์งํฉ A, B ์ฌ์ด์ ์์นด๋ ์ ์ฌ๋ J(A, B) = 2/4 = 0.5๊ฐ ๋๋ค. ์งํฉ A์ ์งํฉ B๊ฐ ๋ชจ๋ ๊ณต์งํฉ์ผ ๊ฒฝ์ฐ์๋ ๋๋์ ์ด ์ ์๋์ง ์์ผ๋ ๋ฐ๋ก J(A, B) = 1๋ก ์ ์ํ๋ค.
์์นด๋ ์ ์ฌ๋๋ ์์์ ์ค๋ณต์ ํ์ฉํ๋ ๋ค์ค์งํฉ์ ๋ํด์ ํ์ฅํ ์ ์๋ค. ๋ค์ค์งํฉ A๋ ์์ "1"์ 3๊ฐ ๊ฐ์ง๊ณ ์๊ณ , ๋ค์ค์งํฉ B๋ ์์ "1"์ 5๊ฐ ๊ฐ์ง๊ณ ์๋ค๊ณ ํ์. ์ด ๋ค์ค์งํฉ์ ๊ต์งํฉ A ∩ B๋ ์์ "1"์ min(3, 5)์ธ 3๊ฐ, ํฉ์งํฉ A ∪ B๋ ์์ "1"์ max(3, 5)์ธ 5๊ฐ ๊ฐ์ง๊ฒ ๋๋ค. ๋ค์ค์งํฉ A = {1, 1, 2, 2, 3}, ๋ค์ค์งํฉ B = {1, 2, 2, 4, 5}๋ผ๊ณ ํ๋ฉด, ๊ต์งํฉ A ∩ B = {1, 2, 2}, ํฉ์งํฉ A ∪ B = {1, 1, 2, 2, 3, 4, 5}๊ฐ ๋๋ฏ๋ก, ์์นด๋ ์ ์ฌ๋ J(A, B) = 3/7, ์ฝ 0.42๊ฐ ๋๋ค.
์ด๋ฅผ ์ด์ฉํ์ฌ ๋ฌธ์์ด ์ฌ์ด์ ์ ์ฌ๋๋ฅผ ๊ณ์ฐํ๋๋ฐ ์ด์ฉํ ์ ์๋ค. ๋ฌธ์์ด "FRANCE"์ "FRENCH"๊ฐ ์ฃผ์ด์ก์ ๋, ์ด๋ฅผ ๋ ๊ธ์์ฉ ๋์ด์ ๋ค์ค์งํฉ์ ๋ง๋ค ์ ์๋ค. ๊ฐ๊ฐ {FR, RA, AN, NC, CE}, {FR, RE, EN, NC, CH}๊ฐ ๋๋ฉฐ, ๊ต์งํฉ์ {FR, NC}, ํฉ์งํฉ์ {FR, RA, AN, NC, CE, RE, EN, CH}๊ฐ ๋๋ฏ๋ก, ๋ ๋ฌธ์์ด ์ฌ์ด์ ์์นด๋ ์ ์ฌ๋ J("FRANCE", "FRENCH") = 2/8 = 0.25๊ฐ ๋๋ค.
๋ฌธ์ ํด์ค
1. ๋ ๋ฌธ์์ฉ ๋ฌถ์ ๊ฒ
2. ๋ ๋ฌธ์์ฉ ๋ฌถ์ ๋ ํ๋๋ผ๋ ์ํ๋ฒณ์ด ์๋๋ผ๋ฉด ํด๋น ๋ฌธ์ ๋ฌถ์์ ๋ฒ๋ฆด ๊ฒ
3. ๋ฌธ์ ๋ฌถ์์ ์ค๋ณต ํ์ฉ
์ ์ธ ๊ฐ์ง๋ง ์ ์ ๋ ํด์ ๋ฌธ์ ๋ฌถ์์ ๋ง๋ค๊ณ , ๊ฐ ๋ฌธ์์ ํฉ์งํฉ๊ณผ ๊ต์งํฉ์ ๊ตฌํ๋ฉด ๋๋ค.
๋ด ์ฝ๋
#include <string>
#include <unordered_map>
#include <iostream>
#include <cctype>
using namespace std;
// ๋ฌธ์์ด์์ 2๊ธ์์ฉ ์๋ผ์ ๋๋ฌธ์๋ก ๋ณํํ๊ณ ์ํ๋ฒณ๋ง ํฌํจ๋ ๊ฒฝ์ฐ์๋ง ๋งต์ ์ถ๊ฐ
void processString(const string& str, unordered_map<string, int>& counter) {
for(int i = 0; i < str.length() - 1; ++i) {
// ๋ ๋ฌธ์๊ฐ ๋ชจ๋ ์ํ๋ฒณ์ธ์ง ํ์ธ
if(!isalpha(str[i]) || !isalpha(str[i+1])) {
continue;
}
// ๋๋ฌธ์๋ก ๋ณํ
string element;
element.push_back(toupper(str[i]));
element.push_back(toupper(str[i+1]));
// ๋งต์ ์นด์ดํ
counter[element]++;
}
}
int solution(string str1, string str2) {
unordered_map<string, int> counter1, counter2;
// ๋ ๋ฌธ์์ด ์ฒ๋ฆฌ
processString(str1, counter1);
processString(str2, counter2);
int intersection = 0;
int union_size = 0;
// ๊ต์งํฉ ๊ณ์ฐ
for(const auto& pair : counter1) {
const string& element = pair.first;
int count1 = pair.second;
int count2 = counter2[element];
intersection += min(count1, count2);
union_size += max(count1, count2);
// counter2์์ ์ฒ๋ฆฌํ ์์ ์ ๊ฑฐ
counter2.erase(element);
}
// counter2์ ๋จ์ ์์๋ค์ str1์ ์๋ ์์๋ค์ด๋ฏ๋ก ํฉ์งํฉ์ ์ถ๊ฐ
for(const auto& pair : counter2) {
union_size += pair.second;
}
// ์์นด๋ ์ ์ฌ๋ ๊ณ์ฐ
if(union_size == 0) {
return 65536; // ๋ ์งํฉ์ด ๋ชจ๋ ๊ณต์งํฉ์ธ ๊ฒฝ์ฐ
}
return (intersection * 65536) / union_size;
'๐ฅ๏ธ Study Note > Coding Test' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค]์ ์ฐ๊ทผ๋ฌด์ (C++) (0) | 2025.04.14 |
---|---|
[๋ฐฑ์ค 1926] ๊ทธ๋ฆผ(C++) (0) | 2023.11.18 |
[๋ฐฑ์ค 1931] ํ์์ค ๋ฐฐ์ (C++) (0) | 2023.10.26 |
[๋ฐฑ์ค 1003] ํผ๋ณด๋์น ํจ์ (C++) (0) | 2023.10.25 |
[Hacker Rank] Organizing Containers of Balls (C++) (1) | 2023.10.09 |