๋ชฉ๋กJavaScript (140)
๐ค ์์งlog ๐ค
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - rny_string ๐ ๋ฌธ์ ์ค๋ช 'm'๊ณผ "rn"์ด ๋ชจ์์ด ๋น์ทํ๊ฒ ์๊ธด ์ ์ ํ์ฉํด ๋ฌธ์์ด์ ์ฅ๋์ ํ๋ ค๊ณ ํฉ๋๋ค. ๋ฌธ์์ด rny_string์ด ์ฃผ์ด์ง ๋, rny_string์ ๋ชจ๋ 'm'์ "rn"์ผ๋ก ๋ฐ๊พผ ๋ฌธ์์ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ rny_string์ ๊ธธ์ด ≤ 100 rny_string์ ์์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ๐ ํ์ด function solution(rny_string) { return rny_string.replaceAll("m","rn") } โ "m"์ "rn" ์ผ๋ก ๋ฐ๊ฟ์ฃผ๋ฉด ๋๋๊ฑฐ๋ผ replace( ) ์ฌ์ฉํ๋ฉด ๋ ๊ฒ๊ฐ์๊ณ , ๋ฌธ์์ด์ m์ด 2๊ฐ ์ด์์ผ์๋ ์๊ธฐ์ replaceAll( ) ๋ฉ์๋ ์ฌ..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋๋ฌธ์์ ์๋ฌธ์ ๐ ๋ฌธ์ ์ค๋ช ๋ฌธ์์ด my_string์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋๋ฌธ์๋ ์๋ฌธ์๋ก ์๋ฌธ์๋ ๋๋ฌธ์๋ก ๋ณํํ ๋ฌธ์์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ my_string์ ๊ธธ์ด ≤ 1,000 my_string์ ์์ด ๋๋ฌธ์์ ์๋ฌธ์๋ก๋ง ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ๐ ํ์ด function solution(my_string) { const answer = []; for ( let i = 0; i < my_string.length; i++) { if(my_string[i] === my_string[i].toUpperCase()){ answer.push(my_string[i].toLowerCase()) } else { answer.push(..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ํ๋ ๋ฌธ์์ด ์ฐพ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ํ๋ฒณ์ผ๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด myString๊ณผ pat์ด ์ฃผ์ด์ง๋๋ค. myString์ ์ฐ์๋ ๋ถ๋ถ ๋ฌธ์์ด ์ค pat์ด ์กด์ฌํ๋ฉด 1์ ๊ทธ๋ ์ง ์์ผ๋ฉด 0์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๋จ, ์ํ๋ฒณ ๋๋ฌธ์์ ์๋ฌธ์๋ ๊ตฌ๋ถํ์ง ์์ต๋๋ค. ๐ ์ ํ์กฐ๊ฑด 1 ≤ myString์ ๊ธธ์ด ≤ 100,000 1 ≤ pat์ ๊ธธ์ด ≤ 300 myString๊ณผ pat์ ๋ชจ๋ ์ํ๋ฒณ์ผ๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด์ ๋๋ค. ๐ ํ์ด function solution(myString, pat) { if(myString.toUpperCase().includes(pat.toUpperCase())){ return 1 } else { return 0 } } โ ์ฒ์์๋..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ ๋ฏธ์ฌ์ธ์ง ํ์ธํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ด๋ค ๋ฌธ์์ด์ ๋ํด์ ์ ๋ฏธ์ฌ๋ ํน์ ์ธ๋ฑ์ค๋ถํฐ ์์ํ๋ ๋ฌธ์์ด์ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด, "banana"์ ๋ชจ๋ ์ ๋ฏธ์ฌ๋ "banana", "anana", "nana", "ana", "na", "a"์ ๋๋ค. ๋ฌธ์์ด my_string๊ณผ is_suffix๊ฐ ์ฃผ์ด์ง ๋, is_suffix๊ฐ my_string์ ์ ๋ฏธ์ฌ๋ผ๋ฉด 1์, ์๋๋ฉด 0์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ my_string์ ๊ธธ์ด ≤ 100 1 ≤ is_suffix์ ๊ธธ์ด ≤ 100 my_string๊ณผ is_suffix๋ ์์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ๐ ํ์ด function solution(my_string, is_suffix) { retu..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ ๋์ฌ์ธ์ง ํ์ธํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ด๋ค ๋ฌธ์์ด์ ๋ํด์ ์ ๋์ฌ๋ ํน์ ์ธ๋ฑ์ค๊น์ง์ ๋ฌธ์์ด์ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด, "banana"์ ๋ชจ๋ ์ ๋์ฌ๋ "b", "ba", "ban", "bana", "banan", "banana"์ ๋๋ค. ๋ฌธ์์ด my_string๊ณผ is_prefix๊ฐ ์ฃผ์ด์ง ๋, is_prefix๊ฐ my_string์ ์ ๋์ฌ๋ผ๋ฉด 1์, ์๋๋ฉด 0์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ my_string์ ๊ธธ์ด ≤ 100 1 ≤ is_prefix์ ๊ธธ์ด ≤ 100 my_string๊ณผ is_prefix๋ ์์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ๐ ํ์ด function solution(my_string, is_prefix) { if (my_s..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ฐฐ์ด ๋ง๋ค๊ธฐ 1 ๐ ๋ฌธ์ ์ค๋ช ์ ์ n๊ณผ k๊ฐ ์ฃผ์ด์ก์ ๋, 1 ์ด์ n์ดํ์ ์ ์ ์ค์์ k์ ๋ฐฐ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ์ฅํ ๋ฐฐ์ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ n ≤ 1,000,000 1 ≤ k ≤ min(1,000, n) ๐ ํ์ด function solution(n, k) { const answer = [] for (let i = 1; i
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ค์์ 5๋ฑ๊น์ง ๐ ๋ฌธ์ ์ค๋ช ์ ์๋ก ์ด๋ฃจ์ด์ง ๋ฆฌ์คํธ num_list๊ฐ ์ฃผ์ด์ง๋๋ค. num_list์์ ๊ฐ์ฅ ์์ 5๊ฐ์ ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ด์ ๋ฆฌ์คํธ๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 6 ≤ num_list์ ๊ธธ์ด ≤ 30 1 ≤ num_list์ ์์ ≤ 100 ๐ ํ์ด function solution(num_list) { const new_list = num_list.sort((a,b) => a-b) return new_list.slice(0,5) } โ ์ฐ์ num_list๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค ์๋ก์ด ๋ฐฐ์ด์์ 0๋ฒ์งธ๋ถํฐ 5๋ฒ์งธ๊น์ง sliceํ์ฌ return ํด ์ฃผ์๋ค.
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - n์ ๋ฐฐ์ ๊ณ ๋ฅด๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ ์ n๊ณผ ์ ์ ๋ฐฐ์ด numlist๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, numlist์์ n์ ๋ฐฐ์๊ฐ ์๋ ์๋ค์ ์ ๊ฑฐํ ๋ฐฐ์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ n ≤ 10,000 1 ≤ numlist์ ํฌ๊ธฐ ≤ 100 1 ≤ numlist์ ์์ ≤ 100,000 ๐ ํ์ด function solution(n, numlist) { return numlist.filter((i) => i % n === 0) } โ n์ ๋ฐฐ์๋ฅผ ๋จผ์ ์ฐพ์์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. ๋ฐฐ์ด์์ n์ผ๋ก ๋๋์์๋ ๋๋จธ์ง๊ฐ 0์ด๋ฉด ๋ฐฐ์์ด๋๊น filter()๋ฉ์๋๋ก i % n === 0 ์กฐ๊ฑด์ ํ์ธํ๊ณ , ๋๋์ด ๋จ์ด์ง๋ ๊ฒฝ์ฐ์๋ง true๋ฅผ ๋ฐํํ์ฌ ํด๋น ์..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ถ๋ถ ๋ฌธ์์ด ๐ ๋ฌธ์ ์ค๋ช ์ด๋ค ๋ฌธ์์ด A๊ฐ ๋ค๋ฅธ ๋ฌธ์์ด B์์ ์ํ๋ฉด A๋ฅผ B์ ๋ถ๋ถ ๋ฌธ์์ด์ด๋ผ๊ณ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ฌธ์์ด "abc"๋ ๋ฌธ์์ด "aabcc"์ ๋ถ๋ถ ๋ฌธ์์ด์ ๋๋ค. ๋ฌธ์์ด str1๊ณผ str2๊ฐ ์ฃผ์ด์ง ๋, str1์ด str2์ ๋ถ๋ถ ๋ฌธ์์ด์ด๋ผ๋ฉด 1์ ๋ถ๋ถ ๋ฌธ์์ด์ด ์๋๋ผ๋ฉด 0์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ str1 ≤ str2 ≤ 20 str1๊ณผ str2๋ ์์ด ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ๐ ํ์ด function solution(str1, str2) { if ( str2.includes(str1)) { return 1 } else { return 0 } } โ ๐ก includes() ๋ฉ์๋๋ ํ๋์ ๋ฌธ์์ด์ด ๋ค๋ฅธ ..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ถ๋ถ ๋ฌธ์์ด์ธ์ง ํ์ธํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ๋ถ๋ถ ๋ฌธ์์ด์ด๋ ๋ฌธ์์ด์์ ์ฐ์๋ ์ผ๋ถ๋ถ์ ํด๋นํ๋ ๋ฌธ์์ด์ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฌธ์์ด "ana", "ban", "anana", "banana", "n"๋ ๋ชจ๋ ๋ฌธ์์ด "banana"์ ๋ถ๋ถ ๋ฌธ์์ด์ด์ง๋ง, "aaa", "bnana", "wxyz"๋ ๋ชจ๋ "banana"์ ๋ถ๋ถ ๋ฌธ์์ด์ด ์๋๋๋ค. ๋ฌธ์์ด my_string๊ณผ target์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, target์ด ๋ฌธ์์ด my_string์ ๋ถ๋ถ ๋ฌธ์์ด์ด๋ผ๋ฉด 1์, ์๋๋ผ๋ฉด 0์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ my_string์ ๊ธธ์ด ≤ 100 my_string์ ์์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. 1 ≤ target์ ๊ธธ์ด ≤ 100 ..