ํฐ์คํ ๋ฆฌ ๋ทฐ
[JavaScript] ํ๋ก๊ทธ๋๋จธ์ค - ๋ด์ค ํด๋ฌ์คํฐ๋ง
๊ฐ๋ฐ๊ฐ๊ตด๐ธ 2022. 8. 11. 15:40[๋ฌธ์ ]
https://school.programmers.co.kr/learn/courses/30/lessons/17677
๋ด์ค ํด๋ฌ์คํฐ๋ง
์ฌ๋ฌ ์ธ๋ก ์ฌ์์ ์์์ง๋ ๋ด์ค, ํนํ ์๋ณด์ฑ ๋ด์ค๋ฅผ ๋ณด๋ฉด ๋น์ท๋น์ทํ ์ ๋ชฉ์ ๊ธฐ์ฌ๊ฐ ๋ง์ ์ ์ ํ์ํ ๊ธฐ์ฌ๋ฅผ ์ฐพ๊ธฐ๊ฐ ์ด๋ ต๋ค. 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๊ฐ ๋๋ค.
์ ๋ ฅ ํ์
- ์ ๋ ฅ์ผ๋ก๋ str1๊ณผ str2์ ๋ ๋ฌธ์์ด์ด ๋ค์ด์จ๋ค. ๊ฐ ๋ฌธ์์ด์ ๊ธธ์ด๋ 2 ์ด์, 1,000 ์ดํ์ด๋ค.
- ์ ๋ ฅ์ผ๋ก ๋ค์ด์จ ๋ฌธ์์ด์ ๋ ๊ธ์์ฉ ๋์ด์ ๋ค์ค์งํฉ์ ์์๋ก ๋ง๋ ๋ค. ์ด๋ ์๋ฌธ์๋ก ๋ ๊ธ์ ์๋ง ์ ํจํ๊ณ , ๊ธฐํ ๊ณต๋ฐฑ์ด๋ ์ซ์, ํน์ ๋ฌธ์๊ฐ ๋ค์ด์๋ ๊ฒฝ์ฐ๋ ๊ทธ ๊ธ์ ์์ ๋ฒ๋ฆฐ๋ค. ์๋ฅผ ๋ค์ด "ab+"๊ฐ ์ ๋ ฅ์ผ๋ก ๋ค์ด์ค๋ฉด, "ab"๋ง ๋ค์ค์งํฉ์ ์์๋ก ์ผ๊ณ , "b+"๋ ๋ฒ๋ฆฐ๋ค.
- ๋ค์ค์งํฉ ์์ ์ฌ์ด๋ฅผ ๋น๊ตํ ๋, ๋๋ฌธ์์ ์๋ฌธ์์ ์ฐจ์ด๋ ๋ฌด์ํ๋ค. "AB"์ "Ab", "ab"๋ ๊ฐ์ ์์๋ก ์ทจ๊ธํ๋ค.
์ถ๋ ฅ ํ์
์ ๋ ฅ์ผ๋ก ๋ค์ด์จ ๋ ๋ฌธ์์ด์ ์์นด๋ ์ ์ฌ๋๋ฅผ ์ถ๋ ฅํ๋ค. ์ ์ฌ๋ ๊ฐ์ 0์์ 1 ์ฌ์ด์ ์ค์์ด๋ฏ๋ก, ์ด๋ฅผ ๋ค๋ฃจ๊ธฐ ์ฝ๋๋ก 65536์ ๊ณฑํ ํ์ ์์์ ์๋๋ฅผ ๋ฒ๋ฆฌ๊ณ ์ ์๋ถ๋ง ์ถ๋ ฅํ๋ค.
[ํ์ด]
๋ฌธ์์ด 2๊ฐ์ ๋ค์ค์งํฉ์ ๋ํ ์์นด๋ ์ ์ฌ๋๋ฅผ ๊ตฌํด์ผํ๋ ๋ฌธ์ ๋ก, ์ฐ์ ์์นด๋ ์ ์ฌ๋๋ฅผ ๊ณ์ฐํ๊ธฐ ์์ ํฉ์งํฉ๊ณผ ๊ต์งํฉ์ ๊ตฌํดํ ํฉ๋๋ค.
๋ฌธ์ ์ ์์ ์ฒ๋ผ A = { 1, 1, 2, 2, 3 } ์ B = { 1, 2, 2, 4, 5 }์ ๊ต์งํฉ๊ณผ ํฉ์งํฉ์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
ํ์ฌ A, B๋ฅผ ํ์์ค์ธ index์ ์์น๋ฅผ ๊ฐ๊ฐ p1, p2๋ผ๊ณ ์๊ฐํ๊ณ ๋ฌธ์ ๋ฅผ ํ์ดํ์์ต๋๋ค.
p1๊ณผ p2 ๋ชจ๋ 0๋ถํฐ ์์ํ์ฌ ๋์ ๋๋ค๋ฅผ๋๊น์ง ๋น๊ต์ฐ์ฐ์ ํตํด ๋ค์๊ณผ ๊ฐ์ ์์ ์ ๋ฐ๋ณตํฉ๋๋ค.
- A[p1] === B[p2]๋ผ๋ฉด ํฉ์งํฉ, ๊ต์งํฉ์ AorB์ ๊ฐ์ ์ถ๊ฐํ๊ณ p1๊ณผ p2๋ฅผ ๋ชจ๋ ์ค๋ฅธ์ชฝ์ผ๋ก ํ์นธ ์ด๋
- A[p1] < B[p2]๋ผ๋ฉด ํฉ์งํฉ์ A์ ๊ฐ์ ์ถ๊ฐํ๊ณ p1๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ์นธ ์ด๋
- A[p1] > B[p2]๋ผ๋ฉด ํฉ์งํฉ์ B์ ๊ฐ์ ์ถ๊ฐํ๊ณ p2๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ์นธ ์ด๋
์ด๋, ๋ง์ฝ p1์ด๋ p2์ ๊ฐ์ด ๊ฐ๋ฅดํค๋ ๋ฐฐ์ด์ ๋ง์ง๋ง index๊น์ง ๋น๊ต์ฐ์ฐ์ ์๋ฃํ๋ค๋ฉด, ์์ง ๋์ ๋๋ค๋ฅด์ง ๋ชปํ ๋ฐฐ์ด์ ๊ฐ์ ๋ชจ๋ ํฉ์งํฉ์ ์ถ๊ฐํ๊ณ ์ฐ์ฐ์ ๋๋ ๋๋ค.
์ฐ์ฐ ๊ณผ์ ์ ์์ธํ ์ดํด๋ณด์๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1) p1 = 0, p2 = 0
A[p1]๊ณผ B[p2]์ ๊ฐ์ด ๋๋ค 1์ด๋ฏ๋ก ๊ต์งํฉ, ํฉ์งํฉ์ ๋ชจ๋ ์ถ๊ฐํ๊ณ p1++, p2++ ์ฐ์ฐ์ ํด์ค๋๋ค.
2) p2 = 1, p2 = 1
A[p1] < B[p2] -> p1++, ํฉ์งํฉ์ 1 ๋ฃ์
3) p1 = 2, p2 = 1
A[p1] === B[p2] -> p1++, p2++, ํฉ์งํฉ์ 2๋ฃ๊ณ , ๊ต์งํฉ 2๋ฃ์
3) p2 = 3, p3 = 2
A[p1] === B[p2] -> p1++, p2++, ํฉ์งํฉ์ 2๋ฃ๊ณ , ๊ต์งํฉ 2๋ฃ์
3) p2 = 4, p3 = 3
A[p1] < B[p2] -> p1++, ํฉ์งํฉ๋ค 3๋ฃ์
4) p1์ index๊ฐ A์ length์ธ 5๊ฐ ๋์ด ๋ฐ๋ณต ์ฐ์ฐ์ ๋๋ด๊ณ ํ์ฌ 3(p2์ธ ๊ฐ) ~ 4(B์ lengt-1)๊น์ง์ ๊ฐ์ ํฉ์งํฉ์ ์ถ๊ฐ
๋ฐ๋ผ์ ํฉ์งํฉ = {1, 1, 2, 2, 3, 4, 5}, ๊ต์งํฉ = {1, 2, 2}๋ฅผ ๊ตฌํ ์ ์์ต๋๋ค.
๋ฌธ์ ์์๋ ๋ฌธ์๋ก ์ด๋ฃจ์ด์ง ๊ธธ์ด 2์ ๋ฌธ์์์ ์ด์ฉํ๋ผ๊ณ ํ์๊ธฐ ๋๋ฌธ์ ์งํฉ์ ๊ตฌํด์ฃผ๋ ๊ณผ์ ์์ ์ ๊ท์์ ์ฌ์ฉํ์ฌ ๊ตฌํด์ฃผ์๊ณ , ์์ ๋ฐฉ์๋๋ก ํ์์ ์งํํ๊ธฐ ์ํด sort ์ฐ์ฐ์ ํตํด ์ ๋ ฌํ์์ต๋๋ค.
[์ฝ๋]
function solution(str1, str2) {
let answer = 0;
const makeSet = (str) => {
const strArr = [];
const regex = /^[a-z|A-Z]+$/;
for(let i=0;i<str.length-1;i++) {
const subStr = str.substring(i, i+2).toUpperCase();
if(regex.test(subStr)) strArr.push(subStr);
}
return strArr;
}
// ์ ๋ ฌ๋ ์ค๋ณต SET์ ๊ฐ๊ฐ ๋ง๋ฆ
const str1Set = makeSet(str1).sort();
const str2Set = makeSet(str2).sort();
let p1 = 0;
let p2 = 0;
const union = [];
const intersection = [];
while(p1 < str1Set.length && p2 < str2Set.length) {
// p1, p2 ๊ธฐ์ค์ผ๋ก ๋น๊ตํ๊ณ ํ์์ ์งํ
if(str1Set[p1] === str2Set[p2]) {
union.push(str1Set[p1]);
intersection.push(str1Set[p1]);
p1++;
p2++;
} else if(str1Set[p1] < str2Set[p2]) {
union.push(str1Set[p1]);
p1++;
} else {
union.push(str2Set[p2]);
p2++;
}
}
// ์์ง str1์ด ๋ค ๋ค์ด๊ฐ์ง ๋ชปํ์ผ๋ฉด ๋๋จธ์ง๋ฅผ union์ ์ฑ์์ค
if(p1 < str1Set.length) {
for(let i=p1;i<str1Set.length;i++) {
union.push(str1Set[i]);
}
}
// ์์ง str2์ด ๋ค ๋ค์ด๊ฐ์ง ๋ชปํ์ผ๋ฉด ๋๋จธ์ง๋ฅผ union์ ์ฑ์์ค
if(p2 < str2Set.length) {
for(let i=p2;i<str2Set.length;i++) {
union.push(str2Set[i]);
}
}
const uniLen = union.length;
const interLen = intersection.length;
if(uniLen === 0 && interLen === 0) {
answer = 65536;
} else {
answer = Math.floor((interLen/uniLen)*65536);
}
return answer;
}
'Algorithm > Programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JavaScript] ํ๋ก๊ทธ๋๋จธ์ค - ํ๊ฒ ๋๋ฒ (0) | 2022.08.23 |
---|---|
[JavaScript] ํ๋ก๊ทธ๋๋จธ์ค - ์ฃผ์ฐจ ์๊ธ ๊ณ์ฐ (0) | 2022.08.18 |
[Java] ํ๋ก๊ทธ๋๋จธ์ค - ํธํ ๋ฐฉ ๋ฐฐ์ (0) | 2022.07.22 |
[Java] ํ๋ก๊ทธ๋๋จธ์ค - ์ง๊ฒ๋ค๋ฆฌ ๊ฑด๋๊ธฐ (0) | 2022.07.13 |
[Java] ํ๋ก๊ทธ๋๋จธ์ค - ๋ถ๋ ์ฌ์ฉ์ (0) | 2022.07.12 |
- Total
- Today
- Yesterday
- ๋ ์์ปฌ ํ๊ฒฝ
- http
- ๋ฐฑ์ค
- ํจ์ํ ํ๋ก๊ทธ๋๋ฐ
- ํ๋กํผํฐ
- 2019 ์นด์นด์ค ๊ฐ๋ฐ์ ๊ฒจ์ธ ์ธํด
- JavaScript
- ์ด๋ถํ์
- ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ
- ๋ฐฑ์ค javascript
- ํฌํฌ์ธํฐ
- ์ฝ๋ฉํ ์คํธ
- fp
- map
- ์นด์นด์ค ์ธํด
- ์๋ฐ์คํฌ๋ฆฝํธ
- ๋์์ธ ํจํด
- ํ๋กํ ์ฝ
- Baekjoon
- ๋ชจ๋ ์๋ฐ์คํฌ๋ฆฝํธ deep dive
- ์๋ฐ
- ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ
- ๋คํธ์ํฌ
- ์๊ณ ๋ฆฌ์ฆ
- ์ด์์ฒด์
- TDD
- ๋ฐฑ์ค node.js
- ํ๋ก๊ทธ๋๋จธ์ค
- git
- ์ ์ญ ๋ณ์
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 | 31 |