์ด์
function solution(s) {
while (s.length > 0) {
for (let i = 0; i < s.length; i++) {
const ch1 = s[i];
const ch2 = s[i + 1];
// console.log(ch1, ch2);
if (ch1 === ch2) {
s = s.substring(0, i) + s.substring(i + 2);
// console.log("s : ", s);
break;
}
if (i === s.length - 1) {
return 0;
}
}
}
return 1;
}
// console.log(solution("baabaa"));
console.log(solution("cdcd"));
s
๋ฌธ์์ด ์ ์ฒด๋ฅผ ์ํํ๋ฉด์
๋ฐ๋ณต์ ์ผ๋ก ์์ ๋ ๊ธ์๋ฅผ ๋น๊ตํ๊ณ
์ ๋ถ ๋ค ์ ๊ฑฐํด์ while ๋ฌธ์ ๋น ์ ธ๋์ค๋ฉด 1์ ๋ฐํํ๊ณ ,
๋ฐํํ์ง ๋ชปํด์ i๊ฐ s.length-1
์ฆ ๋ฌธ์์ด ๋๊น์ง ๋๋ฌํ๋ฉด 0์ ๋ฐํํ๋ ๋ฐฉ์์ผ๋ก ํ์๋ค.
์ ํ๋๋ 18/18์ธ๋ฐ ํจ์จ์ฑ์ด 1/8๋ก ์ฌํ ๋ฎ์๋ค.
์์ธ ํ์
while๊ณผ for ๋ก ๋ฐ๋ณต ์ค์ฒฉ์ด ์์ด์ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ๋ณต์ก๋ ์์ ๋ณด๋ค ๋ฎ์ ๋ณต์ก๋๋ค์
๋ค์ด ์๋ค. (๋ด๋ฆผ์ฐจ์)

์ ๋นจ๊ฐ์ ์์ญ์ด horrible ํ๋ค๋๊ฑธ ๋ณด๋
ํ๋ก๊ทธ๋๋ฐ์ ํ ๋ ์ต๋ํ ๋ฐ๋ณต๋ฌธ ์ค์ฒฉ์ ํผํด์ผ๋๋๊ฒ ๊ฐ๋ค.
๊ทธ๋ผ ์์ ๋ฌธ์ ๋ ๋ฐ๋ณต๋ฌธ ์ค์ฒฉ ์์ด ํ์ด์ผ๋๋ค๋๊ฒ ๋ฌธ์ ์ ์ถ์ ์๋์ผ ๊ฒ์ธ๋ฐ, ์ด๋ป๊ฒ ํ์ด์ผ๋ ๊น?
์ผ๋จ ์์ for๋ฌธ์ด ์ด ํจ์์ ํต์ฌ ๊ธฐ๋ฅ์ ๋ด๋นํ๊ณ ์๊ธฐ ๋๋ฌธ์ ๋ฐ์ while๋ฌธ์ ์ญํ ์ ๋์ฒดํ ์ฝ๋๋ฅผ for ๋ฌธ ์์ ์์ฑํด์ผ๋๊ฒ ์ง?
...(3๋ถ๊ฐ ๊ณ ๋ฏผํ ํด๋ก๋์๊ฒ ๋ฌผ์ด๋ดค๋ค.)
์คํ์ ์ฌ์ฉํ๋ฉด ๋๋ค๊ณ ํ๋ค. ์ด๊ฑธ ์๊ฐ ๋ชปํ๋ค๋.
KOCW ์๋ฃ๊ตฌ์กฐ ์์
์์๋ ๋ค์๋ ๋ด์ฉ์ธ๋ฐ, ์คํ์ ๋ง์ง๋ง๊ฒ, ์ต์ ๊ฒ๊ณผ ๋น๊ตํ ๋ ์ฌ์ฉ๋๋ค.
์ ์คํ์ ์๊ฐํด๋ด์ง ๋ชปํ์๊น?
์ฝ๋ฉํ
์คํธ์์ ์คํ์ ์ฌ์ฉํด ํผ ๋ฌธ์ ๊ฐ ๋ช ๊ฐ ์๊ธฐ๋ํ๊ณ , ์คํ์ ๋ชจ๋ฅด๋๊ฒ๋ ์๋๋ฐ ์ ์ด ๋ฌธ์ ์์ ๋ ์ฌ๋ ค๋ด์ง ๋ชปํ์๊น?
์ฌ์ง์ด ์์ ์ ํ์๋ ๊ดํธ ์ง ๋ง์ถ๊ธฐ ๋ฌธ์ ๋ ์ฌ์ค์ ๊ตฌ์กฐ๋ ๋๊ฐ์๋ฐ ๋ง์ด๋ค....
์ฝ๋ฉํ ์คํธ์์ ์ด๋ค ์๊ณ ๋ฆฌ์ฆ, ์๋ฃ์ ํ์ ์ฌ์ฉํด์ผํ๋์ง ํ์ ํ ์ ์๋๊ฒ ์ค์ํ๋ค๊ณ ์ ์ ๋ค์๋ ํน๊ฐ(์์ธ๊ณ ์ฉ์ผํฐ 6์ 9์ผ ํน๊ฐ)์ด ์๊ฐ๋ฌ๋ค.
๋ฌธ์ ๋ฅผ ์ถ์ํ ํ ์ ์์ด์ผ ํ๋ค.
์ฌ๊ธฐ์ ๋ฐ๋ก ์ํ์ค๋ ฅ์ด ํ๋ก๊ทธ๋๋ฐ์ ๊ฐ์
ํ๋๊ฑฐ ์๋๊น.
"baabaa"
"({}){}"
๋ชจ๋ ์ธ์ ํ ์์ ์ ๊ฑฐํ๋๊ฒ ๋ณธ์ง์ด๋๊น
์คํ๋ฌธ์ ์ ํต์ฌ ํค์๋๋ค๋ก๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒ๋ค์ด ์๋ค๊ณ ํ๋ค.
์ธ์ ํ, ์ฐ์๋, ์, ์ต๊ทผ, ๋๋๋ฆฌ๊ธฐ, ...
๋ฌธ์ ๊ฐ ์๊ตฌํ๋ ๊ณผ์ ๋ฅผ ๋ณธ์ง๋ง ์ถ๋ ค์ ์ถ์ํ ํ ๋ค์์ ํด๋นํ๋ ํค์๋๋ฅผ ์ฐพ๋ ์ฐ์ต์ด ํ์ํ ๊ฒ ๊ฐ๋ค.
๋ต์
function solution(s) {
const stack = [];
for (let i = 0; i < s.length; i++) {
const ch = s[i];
// console.log(ch);
if (stack.length > 0 && stack[stack.length - 1] === ch) {
stack.pop();
} else {
stack.push(ch);
}
}
return stack.length > 0 ? 0 : 1;
}
์ด๋ ๊ฒ ์คํ์ ์ฌ์ฉํด ํ์๊ณ , ํต๊ณผํ๋ค.