Tags
- Python
- PGM
- ๊ทธ๋ํ ์ด๋ก
- stack
- ๊น์ด ์ฐ์ ํ์
- ๊ต์ฌ
- greedy
- CodingTest
- ๋ฐฑํธ๋ํน
- Study
- ์ ์๋ก
- ๋ฌธ์์ด
- DP
- BOJ
- ์ ๋ ฌ
- ๊ตฌํ
- Brute Force Algorithm
- sort
- Java
- dfs
- LV2
- SpringBoot
- ์๋ฃ๊ตฌ์กฐ
- queue
- ์ํ
- Dynamic Programming
- ๋๋น ์ฐ์ ํ์
- BFS
- ๊ทธ๋ํ ํ์
- ์๋ฎฌ๋ ์ด์
Archives
๊ธฐ๋ก๋ฐฉ
Lv.2 : ๋ด์ค ํด๋ฌ์คํฐ๋ง ๋ณธ๋ฌธ
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- ์์นด๋ ์ ์ฌ๋๋ฅผ ๊ตฌํํ๊ธฐ ์ํด ๊ต์งํฉ๊ณผ ํฉ์งํฉ์ ๊ตฌํํ๋ ๋ฌธ์ ์ด๋ค.
- ์ฃผ์ด์ง ๋ ๋ฌธ์์ด์ ํ์ฑ์ด ํ์ํ๋ค.
๐ธ ๋ฌธ์ ํ์ด ๐ธ
- ๋ ๋ฌธ์์ด์ ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์์ผ๋ฏ๋ก, ๋๋ฌธ์ ํน์ ์๋ฌธ์๋ก ์ผ์น์ํจ๋ค.
- 2๋ฌธ์์ฉ ์๋ผ์ ์์๋ก ์ฌ์ฉํ๋๋ฐ, ๋์ด์ฐ๊ธฐ๋ ํน์๋ฌธ์ ๋ฑ ์ํ๋ฒณ์ด ์๋ ๋ฌธ์๊ฐ ํฌํจ๋์ด์์ผ๋ฉด ๋ฐฐ์ ํ๋ค.
- ์ฌ๊ธฐ์ ์ฃผ์ ํ ์ ์ ์ํ๋ฒณ์ด ์๋ ๋ฌธ์๋ค์ ์ ๊ฑฐํ๊ณ 2๋ฌธ์์ฉ ์๋ฅด๋๊ฒ ์๋, ๋จผ์ ์๋ฅธ๋ค์ ํํฐ๋ง ํ๋ ์์์ด๋ค.
- ์ค๋ณต์ ํ์ฉํ๋ ๋ค์ค ์งํฉ์ด๊ธฐ ๋๋ฌธ์ Map์ ๊ฐ์์ ํจ๊ป ์ ์ฅํ๋ค.
- ๊ต์งํฉ์ ๋ ์งํฉ์ ๊ณตํต ์์๋ฅผ ์ฐพ๊ณ , ๋ ๊ฐ์ค ์ต์๊ฐ์ ๊ต์งํฉ ๊ฐ์์ ๋ํ๋ค.
- ํฉ์งํฉ์ ๋ ์งํฉ์ ๊ณตํต ์์์ ๋ ๊ฐ์์๋ ์ต๋๊ฐ์ ๋ํ๊ณ , ๊ฒน์น์ง ์๋ ์์ ๊ฐ๋ ๋ํด์ค๋ค.
- ๊ต์งํฉ / ํฉ์งํฉ * 65536 ์ ๋ฐํํ๋ค.
๐ธ ์ฝ๋ ๐ธ
import java.util.Map;
import java.util.HashMap;
class Solution {
public int solution(String str1, String str2) {
// Input
str1 = str1.toUpperCase();
str2 = str2.toUpperCase();
Map<String, Integer> map1 = new HashMap<>();
Map<String, Integer> map2 = new HashMap<>();
for (int i = 0; i < str1.length() - 1; i++) {
String temp = str1.substring(i, i + 2).replaceAll("[^a-zA-Z]", "");
if (temp.length() != 2)
continue;
if (!map1.containsKey(temp))
map1.put(temp, 1);
else
map1.put(temp, map1.get(temp) + 1);
}
for (int i = 0; i < str2.length() - 1; i++) {
String temp = str2.substring(i, i + 2).replaceAll("[^a-zA-Z]", "");
if (temp.length() != 2)
continue;
if (!map2.containsKey(temp))
map2.put(temp, 1);
else
map2.put(temp, map2.get(temp) + 1);
}
if (map1.isEmpty() && map2.isEmpty())
return 65536;
// ๊ต์งํฉ
double cnt1 = 0;
for (Map.Entry<String, Integer> entry : map1.entrySet()) {
if (map2.containsKey(entry.getKey()) && map2.get(entry.getKey()) > 0) {
cnt1 += Math.min(entry.getValue(), map2.get(entry.getKey()));
}
}
// ํฉ์งํฉ
double cnt2 = 0;
for (Map.Entry<String, Integer> entry : map1.entrySet()) {
if (map2.containsKey(entry.getKey())) {
cnt2 += Math.max(entry.getValue(), map2.get(entry.getKey()));
map2.remove(entry.getKey());
} else {
cnt2 += entry.getValue();
}
}
for (Map.Entry<String, Integer> entry : map2.entrySet()) {
cnt2 += entry.getValue();
}
return (int)(cnt1 / cnt2 * 65536);
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ๋์๋ฌธ์ ๊ตฌ๋ถ์ด ์์ผ๋ฏ๋ก, ์ฃผ์ด์ง str1์ str2๋ฅผ ๋๋ฌธ์๋ก ๋ณํํด์ ํต์ผํ๋ค.
- ๋ ์งํฉ์ ์์๋ฅผ ์ ์ฅํ๊ธฐ ์ํด Map์ 2๊ฐ ๋ง๋ ๋ค.
- ๊ฐ๊ฐ 2๋ฌธ์์ฉ ์๋ฅด๊ณ ์ํ๋ฒณ์ ์ ์ธํ ๋ฌธ์๋ ์ ๊ฑฐํด์ ๊ธธ์ด๊ฐ 2์ด๋ฉด ์งํฉ์ ํฌํจํ๋ค.
- ์งํฉ์ ์ฒ์ ๋ฃ๋ ์์๋ฉด ๊ฐ์ 1, ์ฒ์์ด ์๋๋ฉด ๊ธฐ์กด๊ฐ+1 ๋ก ์ ์ฅํ๋ค.
- ๋ง์ฝ ๋ ์งํฉ์ ์์ ๊ฐ์๊ฐ ๋ชจ๋ 0์ด๋ผ๋ฉด, ํฉ์งํฉ์ ๊ฐ์๊ฐ 0์ด ๋์จ๋ค. ๋ฌธ์ ์์ 1๋ก ๊ฐ์ฐํ๋ผ ํ์ผ๋ฏ๋ก, 1 * 65536 ์ ๋ฐํํ๋ค.
- ๊ต์งํฉ์ ๊ฒน์น๋ ์์๋ฅผ ์ฐพ๊ณ , ์ ์ฅ๋ ๋ ๊ฐ์ค ์ต์๊ฐ์ ๊ต์งํฉ ๊ฐ์์ ๋ํ๋ค.
- ํฉ์งํฉ์ ๊ฒน์น๋ ์์๋ฅผ ์ฐพ๊ณ , ์ ์ฅ๋ ๋ ๊ฐ์ค ์ต๋๊ฐ์ ํฉ์งํฉ ๊ฐ์์ ๋ํ๋ค.
- ์ถ๊ฐ๋ก ๊ฒน์น์ง ์์ ์์์ ๊ฐ๋ ํฉ์งํฉ ๊ฐ์์ ๋ํ๋ค.
- ๊ต์งํฉ / ํฉ์งํฉ * 65536์ ๋ฐํํ๋ค.
๐ธ end ๐ธ
- ์นด์นด์ค ๋ฌธ์ ๋ผ์ ๊ทธ๋ฐ์ง 2๋ ๋ฒจ ์น๊ณ ๋ ๊ฝค ๋ณต์กํ๋ ๊ฒ ๊ฐ๋ค. ํ์ง๋ง ๋ค์๋ณด๋ ๊ทธ๋ฅ ๋ฌธ์์ด ์ฒ๋ฆฌ์ ๊ต์งํฉ, ํฉ์งํฉ ๊ตฌํ๊ธฐ์ฌ์ ๊ทธ๋ ๊ฒ ์ด๋ ต์ง๋ ์์ ๊ฒ ๊ฐ๋ค.
- ์ฒ์์ ์ํ๋ฒณ์ด ์๋ ๋ฌธ์๋ฅผ ์ ๊ฑฐํ ๋ค 2๋ฌธ์์ฉ ์๋ฅด๋ ๊ฑฐ๋ก ์ดํดํ๋๋ฐ, ์๋ฅธ ๋ค์ ์ ๊ฑฐํ๋ ๊ฒ์ด์๋ค.
- ์์ 3๋ฒ์์ ๋๋ฒ๊น ํด์ค์ ์ ์ ์์๋ค.
- ์์ 4๋ฒ์ ๋ ์งํฉ์ด ๋ชจ๋ 0์ธ ๊ฒฝ์ฐ๋ฅผ ๋๋ฒ๊น ํด์ค์ ๋ ์์ธ์ฒ๋ฆฌ๋ฅผ ํ ์ ์์๋ค.
- ์์ ๋ง ๋ง์ถ๋ฉด ํต๊ณผ๋๋๋ก ํด๋ฌ์ 2๋ ๋ฒจ์ธ ๊ฒ ๊ฐ๊ธฐ๋ ํ๋ค.
- 2018 KAKAO BLIND RECRUITMENT์ 5๋ฒ ๋ฌธ์ ์ธ๋ฐ, ์ค๊ธ ๋์ด๋์ด๊ณ ์ ๋ต๋ฅ ์ 41.84%์ด๋ค.
- ๋ค์ค ์งํฉ์์ ํฉ์งํฉ, ๊ต์งํฉ์ ๊ตฌํํ๋๊ฒ ํต์ฌ์ธ ๊ฒ ๊ฐ์๋ฐ, ๋ค์ค ์งํฉ์ ๊ตฌํ์ง ์๋๋ผ๋, ๋ณํฉ์ ๋ ฌ์ ํตํด ๊ตฌํํ ์ ์๋ค๊ณ ํ๋ค.
- ๋ค์์ ๋ฌธ์ ํด์ค์ด๋ค.
์ด ๋ฌธ์ ๋ ์์นด๋ ์ ์ฌ๋๋ฅผ ์ค๋ช ํด์ฃผ๊ณ ์์นด๋ ์ ์ฌ๋๋ฅผ ์ง์ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ ๋ฌธ์ ์ ๋๋ค. ์์นด๋ ์ ์ฌ๋๋ ์ค๋ฌด์์๋ ์ ์ฌํ ๋ฌธ์๋ฅผ ํ๋ณํ ๋ ์ฃผ๋ก ์ฐ์ด๋๋ฐ์, ๋ชฐ๋๋๋ผ๋ ๋ฌธ์ ์์ ์์ธํ ์ค๋ช ํด์ฃผ๊ธฐ ๋๋ฌธ์ ์ดํดํ๋๋ฐ ์ด๋ ค์์ ์์์ ๊ฑฐ ๊ฐ์ต๋๋ค. ๊ณต์์ ๋งค์ฐ ๊ฐ๋จํ๋ฐ์, ๊ต์งํฉ์ ํฉ์งํฉ์ผ๋ก ๋๋ ์์ ๋๋ค. ๋ค๋ง, ์ด ๊ฐ์ 0์์ 1 ์ฌ์ด์ ์ค์๊ฐ ๋๋๋ฐ, ์ฌ๊ธฐ์๋ ์ด๋ฅผ ๋ค๋ฃจ๊ธฐ ์ฝ๋๋ก 65536์ ๊ณฑํ ํ ์์์ ์๋๋ฅผ ๋ฒ๋ฆฌ๊ณ ์ ์๋ถ๋ง ์ทจํ๋๋ก ํฉ๋๋ค.
๋ฌธ์ ์ค๋ช ์ ์์์ ์ค๋ณต์ ํ์ฉํ๋ ๋ค์ค์งํฉmultiset์ผ๋ก ๋์ด ์๋๋ฐ, ์์ฃผ ์ ํ๋ ์๋ฃ๊ตฌ์กฐ๊ฐ ์๋๊ณ , ์ผ๋ถ ์ธ์ด์์๋ ๊ธฐ๋ณธ์ผ๋ก ์ ๊ณตํ๋ ์๋ฃ๊ตฌ์กฐ๊ฐ ์๋๋ผ ์ด๋ ค์ํ๋ ๋ถ๋ค์ด ์์์ต๋๋ค. ํ์ง๋ง ๋ค์ค์งํฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฐ์ง ์๋๋ผ๋, ๊ฐ ์์๋ฅผ ์ ๋ ฌ๋ ๋ฐฐ์ด์ ๋ฃ์ ํ ๋ณํฉ ์ ๋ ฌMerge sort์์ ๋ฐฐ์ ๋ ์ฝ๋๋ฅผ ์์ฉ, ์ด๋ ต์ง ์๊ฒ ํฉ์งํฉ๊ณผ ๊ต์งํฉ ํจ์๋ฅผ ์ง์ ๊ตฌํํ ์๋ ์์ต๋๋ค.
๋ค์ค์งํฉ์ ๊ต์งํฉ, ํฉ์งํฉ๋ง ์ ๊ตฌํด๋ธ๋ค๋ฉด ์ด ๋ฌธ์ ๋ ์ด๋ ต์ง ์๊ฒ ํ ์ ์์ผ๋ฉฐ, ๋ค๋ง ์งํฉ A์ B๊ฐ ๋ชจ๋ ๊ณต์งํฉ์ผ ๊ฒฝ์ฐ์๋ ๋๋์ ์ด ์ ์๋์ง ์์ผ๋ฏ๋กdivision by zero ๋ฐ๋ก J(A,B) = 1๋ก ์ ์ํฉ๋๋ค. ์ฆ, 65536์ ๊ณฑํ๋ฉด ์ด ๊ฒฝ์ฐ 1 * 65536 = 65536์ด ์ ๋ต์ด ๋ฉ๋๋ค. ์์ ์ ์ถ๋ ฅ์๋ ํฉ์งํฉ์ด ๊ณต์งํฉ์ธ ๊ฒฝ์ฐ๊ฐ ํฌํจ๋์ด ์์ผ๋ฏ๋ก ์ด ๊ฒฝ์ฐ๋ง ์ฃผ์ํ๋ค๋ฉด ์ฝ๊ฒ ํ ์ ์๋ ๋ฌธ์ ์ ๋๋ค.
์ด ๋ฌธ์ ์ ์ ๋ต๋ฅ ์ 41.84%์ ๋๋ค.
728x90
'CodingTest > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Lv.2 : ์์ถ (0) | 2023.11.09 |
---|---|
Lv.2 : k์ง์์์ ์์ ๊ฐ์ ๊ตฌํ๊ธฐ (0) | 2023.11.08 |
Lv.2 : ํ๋ก์ธ์ค (0) | 2023.11.03 |
BOJ_1235 : ํ์ ๋ฒํธ (0) | 2023.11.02 |
Lv.2 : ๊ธฐ๋ฅ๊ฐ๋ฐ (0) | 2023.11.02 |