๋ฌธ์
๋ฌธ์ ์ ๊ทผ
1. ๋ฐฐ์ด์ ๋ค์ง์๋ ๊ฒ์ฒ๋ผ reverse๊ฐ์ ์ฝ๋๊ฐ ์๋์ง ์ดํด๋ณด์์ง๋ง ๋ฌธ์์ด์ ๋ค์ง์ ์ ์๋ ์ฝ๋๋ ๋ฐ๋ก ์กด์ฌํ๋ ๊ฒ์ด ์์๋ค.
๊ทธ๋ ๋ค๋ฉด for๋ฌธ์ผ๋ก ์ฃผ์ด์ง ๋ฌธ์์ด์ ๊ฐ๊ฐ์ ์์๋ ์ ๊ทผ์ด ๊ฐ๋ฅํ์ง ํ์ธํด๋ณด์๋๋ฐ, ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค.
๊ทธ๋ผ ํด๋น ๋ฌธ์์ด์ ๋ฐํํ ๋ฌธ์์ด์ +=์ฐ์ฐ์๋ฅผ ํตํด์ ๋์ ์์ผ ๋ฐํํ๋ฉด ๋๊ฒ ๊ตฌ๋?? ์ถ์๋ค.
์ ์ถ ์ฝ๋
function solution(my_string) {
var answer = '';
for (i = my_string.length - 1; i >= 0; i--) {
answer += my_string[i];
}
return answer;
}
for ๋ฌธ์ ์ฌ์ฉํ ์ฝ๋์ด๋ค.
๋ค๋ฅธ ๋ถ๋ค์ ์ฝ๋
๋ถ๋ช ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ๋ฌธ์์ด์ ๋ค์ง์ ์ ์๋ ๋ฐฉ๋ฒ์ด ์์ ๊ฒ์ด๋ค ํ๊ณ , ์ฌ๋ฌ ํฌ์คํ ๋ค์ ์ฐพ์๋ณด๊ฒ ๋์๋ค.
function reverseString(str) {
// 1. split() ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์ ๋ฐฐ์ด์ ๋ฐํํ๊ธฐ
var splitString = str.split(""); // var splitString = "hello".split("");
// ["h", "e", "l", "l", "o"]
// 2. reverse() ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์ ๋ฐฐ์ด์ ์์๋ฅผ ๋ค์ง๊ธฐ
var reverseArray = splitString.reverse(); // var reverseArray = ["h", "e", "l", "l", "o"].reverse();
// ["o", "l", "l", "e", "h"]
// 3. join() ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ๋ฌธ์์ด๋ก ๊ฒฐํฉํ๊ธฐ
var joinArray = reverseArray.join(""); // var joinArray = ["o", "l", "l", "e", "h"].join("");
// "olleh"
// 4. ๋ฐ์ ๋ ๋ฌธ์์ด์ ๋ฐํํ๊ธฐ
return joinArray; // "olleh"
}
reverseString("hello");
1. split ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ์ฃผ์ด์ง ๋ฌธ์์ด์ ์๋ก์ด ๋ฐฐ์ด๋ก ๋ํ๋ด๊ณ ,
2. reverse๋ฅผ ํตํด ๋ฐฐ์ด๋ก ๋ํ๋ธ ๋ฌธ์์ด์ ๊ฐ ์์๋ฅผ ๋ค์ง์ด ์ฃผ์๋ค.
join์ ๋ฐ๋ก ์ฌ์ฉํด๋ณด๋ ๊ฒ์ด ์ฒ์์ด๋ผ ์ฌ์ฉ๋ฒ๊ณผ ์ด์ฉ๋ฒ์ mdn๋ฌธ์๋ฅผ ์ฐธ์กฐํ๋ค.
๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ
function reverseString(str) {
if (str === "") // This is the terminal case that will end the recursion
return "";
else
return reverseString(str.substring(1)) + str.charAt(0);
/*
์ฌ๊ท ๋ฉ์๋์ ์ฒซ ๋ฒ์งธ ๋จ๊ณ
You need to remember that you won’t have just one call, you’ll have several nested calls
Each call: str === "?" reverseString(str.subst(1)) + str.charAt(0)
1st call – reverseString("Hello") will return reverseString("ello") + "h"
2nd call – reverseString("ello") will return reverseString("llo") + "e"
3rd call – reverseString("llo") will return reverseString("lo") + "l"
4th call – reverseString("lo") will return reverseString("o") + "l"
5th call – reverseString("o") will return reverseString("") + "o"
์ฌ๊ท ๋ฉ์๋์ ๋ ๋ฒ์งธ ๋จ๊ณ
The method hits the if condition and the most highly nested call returns immediately
5th call will return reverseString("") + "o" = "o"
4th call will return reverseString("o") + "l" = "o" + "l"
3rd call will return reverseString("lo") + "l" = "o" + "l" + "l"
2nd call will return reverserString("llo") + "e" = "o" + "l" + "l" + "e"
1st call will return reverserString("ello") + "h" = "o" + "l" + "l" + "e" + "h"
*/
}
reverseString("hello");
์ฌ๊ท๋ฅผ ํตํ ๋ฌธ์์ด์ ๋ค์ง๋ ๋ฐฉ๋ฒ์ด๋ค.
์์์ ์ฌ์ฉ๋๋ ์ฝ๋์ธ substring๊ณผ charAt์ ๋ํ์ฌ ๊ฒ์ํด๋ณด์๋ค.
substring์ ์ธ์๊ฐ์ผ๋ก ์์ํ index์ ์ซ์์ ๊ทธ ์ดํ๋ก ์ ํ์ต์ ์ธ ๋ฐํํ index์ ์ซ์๋ฅผ ์ง์ ํ ์ ์๋ค.
charAt์ ์ธ์๋ก index๋ฅผ ๋ฐ์ผ๋ฉฐ ํด๋น index์ ๋ฌธ์์ด์ด ๋ฐํ๋๋ค.
#ํ๋ก๊ทธ๋๋จธ์ค #์ฝ๋ฉํ ์คํธ #๋ฌธ์์ด_๋ค์ง๊ธฐ
'Coding Test' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ฝ๋ฉ ํ ์คํธ] : ์ ์ ์์น ๊ตฌํ๊ธฐ (0) | 2023.12.27 |
---|---|
[์ฝ๋ฉ ํ ์คํธ] : ํผ์ ๋๋ ๋จน๊ธฐ(3) (0) | 2023.10.22 |
[์ฝ๋ฉ ํ ์คํธ] : ๋จธ์ฑ์ด๋ณด๋ค ํค ํฐ ์ฌ๋ (0) | 2023.10.22 |
[์ฝ๋ฉ ํ ์คํธ] : ๋ฐฐ์ด ๋ ๋ฐฐ ๋ง๋ค๊ธฐ (0) | 2023.10.22 |
[์ฝ๋ฉ ํ ์คํธ] : ์ค๋ณต๋ ์ซ์ ๊ฐ์ (1) | 2023.10.22 |