๋ชฉ๋ก์ ์ฒด ๊ธ (244)
๐ค ์์งlog ๐ค
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๊ฐ๋จํ ๋ ผ๋ฆฌ ์ฐ์ฐ ๐ ๋ฌธ์ ์ค๋ช boolean ๋ณ์ x1, x2, x3, x4๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋ค์์ ์์ true/false๋ฅผ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. (x1 ∨ x2) ∧ (x3 ∨ x4) ๐ ์ ํ์กฐ๊ฑด ๐ ํ์ด function solution(x1, x2, x3, x4) { const answer = (x1 || x2) && (x3 || x4); return answer; } โ ์ฒ์์๋ ์ดํด๊ฐ ์๋์ด์ ๊ฒ์ํด๋ณด์๋๋ (∨)๋ OR ๋ ผ๋ฆฌ ์ฐ์ฐ์ด๊ณ (∧)๋ AND ๋ ผ๋ฆฌ ์ฐ์ฐ์ด ์ด์๋ค. (x1 ∨ x2) ∧ (x3 ∨ x4) ์์ ์ฐ์ฐ์๋ก ํ์ด์ returnํด์ฃผ์๋ค.
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ปคํผ ์ฌ๋ถ๋ฆ ๐ ๋ฌธ์ ์ค๋ช ํ์ ๋ง๋ด์ธ ์ฒ ์๋ ์๋ฉ๋ฆฌ์นด๋ ธ์ ์นดํ ๋ผํ ๋ง ํ๋งคํ๋ ์นดํ์์ ํ์๋ค์ ์ปคํผ๋ฅผ ์ฌ๋ ค๊ณ ํฉ๋๋ค. ์๋ฉ๋ฆฌ์นด๋ ธ์ ์นดํ ๋ผํ ์ ๊ฐ๊ฒฉ์ ์ฐจ๊ฐ์ด ๊ฒ๊ณผ ๋จ๊ฑฐ์ด ๊ฒ ์๊ด์์ด ๊ฐ๊ฐ 4500, 5000์์ ๋๋ค. ๊ฐ ํ์์๊ฒ ๋ง์ค ๋ฉ๋ด๋ฅผ ์ ์ด๋ฌ๋ผ๊ณ ํ์๊ณ , ๊ทธ ์ค์์ ๋ฉ๋ด๋ง ์ ์ ํ์์ ๊ฒ์ ์ฐจ๊ฐ์ด ๊ฒ์ผ๋ก ํต์ผํ๊ณ "์๋ฌด๊ฑฐ๋"๋ฅผ ์ ์ ํ์์ ๊ฒ์ ์ฐจ๊ฐ์ด ์๋ฉ๋ฆฌ์นด๋ ธ๋ก ํต์ผํ๊ธฐ๋ก ํ์์ต๋๋ค. ๊ฐ ์ง์์ด ์ ์ ๋ฉ๋ด๊ฐ ๋ฌธ์์ด ๋ฐฐ์ด order๋ก ์ฃผ์ด์ง ๋, ์นดํ์์ ๊ฒฐ์ ํ๊ฒ ๋ ๊ธ์ก์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. order์ ์์๋ ์๋์ ๊ฒ๋ค๋ง ๋ค์ด์ค๊ณ , ๊ฐ๊ฐ์ ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. ๐ ์ ํ์กฐ๊ฑด 1 ≤ order์ ๊ธธ์ด ≤ 1,000 ๐ ํ์ด func..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๊ธ์ ์ง์ฐ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ๋ฌธ์์ด my_string๊ณผ ์ ์ ๋ฐฐ์ด indices๊ฐ ์ฃผ์ด์ง ๋, my_string์์ indices์ ์์์ ํด๋นํ๋ ์ธ๋ฑ์ค์ ๊ธ์๋ฅผ ์ง์ฐ๊ณ ์ด์ด ๋ถ์ธ ๋ฌธ์์ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ indices์ ๊ธธ์ด
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ฌธ์์ด ์๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ๊ธธ์ด๊ฐ ๊ฐ์ ๋ ๋ฌธ์์ด str1๊ณผ str2๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ ๋ฌธ์์ด์ ๊ฐ ๋ฌธ์๊ฐ ์์์๋ถํฐ ์๋ก ๋ฒ๊ฐ์๊ฐ๋ฉด์ ํ ๋ฒ์ฉ ๋ฑ์ฅํ๋ ๋ฌธ์์ด์ ๋ง๋ค์ด return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ str1์ ๊ธธ์ด = str2์ ๊ธธ์ด ≤ 10 str1๊ณผ str2๋ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด์ ๋๋ค. ๐ ํ์ด function solution(str1, str2) { let answer = ''; for ( let i = 0; i < str1.length; i++ ) { answer += str1[i]+str2[i] } return answer; } โ ๋ ๋ฌธ์์ด์ ๋ฒ๊ฐ์๊ฐ๋ฉด์ ๊ฒฐํฉํ ๊ฒฐ๊ณผ๊ฐ ์ ์ฅ๋ answer ๋ณ์๋ฅผ ๋น ๋ฌธ์์ด๋ก ์ด..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ธ๋ก ์ฝ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ๋ฌธ์์ด my_string๊ณผ ๋ ์ ์ m, c๊ฐ ์ฃผ์ด์ง๋๋ค. my_string์ ํ ์ค์ m ๊ธ์์ฉ ๊ฐ๋ก๋ก ์ ์์ ๋ ์ผ์ชฝ๋ถํฐ ์ธ๋ก๋ก c๋ฒ์งธ ์ด์ ์ ํ ๊ธ์๋ค์ ๋ฌธ์์ด๋ก return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด my_string์ ์์๋ฌธ์๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. 1 ≤ m ≤ my_string์ ๊ธธ์ด ≤ 1,000 m์ my_string ๊ธธ์ด์ ์ฝ์๋ก๋ง ์ฃผ์ด์ง๋๋ค. 1 ≤ c ≤ m ๐ ํ์ด function solution(my_string, m, c) { let answer = ""; for (let i = c - 1; i < my_string.length; i += m) { answer += my_string[i]; } retu..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ฌธ์์ด ๋ฐ๊ฟ์ ์ฐพ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ๋ฌธ์ "A"์ "B"๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด myString๊ณผ pat๊ฐ ์ฃผ์ด์ง๋๋ค. myString์ "A"๋ฅผ "B"๋ก, "B"๋ฅผ "A"๋ก ๋ฐ๊พผ ๋ฌธ์์ด์ ์ฐ์ํ๋ ๋ถ๋ถ ๋ฌธ์์ด ์ค pat์ด ์์ผ๋ฉด 1์ ์๋๋ฉด 0์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ myString์ ๊ธธ์ด ≤ 100 1 ≤ pat์ ๊ธธ์ด ≤ 10 myString๊ณผ pat๋ ๋ฌธ์ "A"์ "B"๋ก๋ง ์ด๋ฃจ์ด์ง ๋ฌธ์์ด์ ๋๋ค. ๐ ํ์ด function solution(myString, pat) { for (let i = 0; i < myString.length; i++) { let answer = ""; for (let j = 0; j < myString.l..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๊ผฌ๋ฆฌ ๋ฌธ์์ด ๐ ๋ฌธ์ ์ค๋ช ๋ฌธ์์ด๋ค์ด ๋ด๊ธด ๋ฆฌ์คํธ๊ฐ ์ฃผ์ด์ก์ ๋, ๋ชจ๋ ๋ฌธ์์ด๋ค์ ์์๋๋ก ํฉ์น ๋ฌธ์์ด์ ๊ผฌ๋ฆฌ ๋ฌธ์์ด์ด๋ผ๊ณ ํฉ๋๋ค. ๊ผฌ๋ฆฌ ๋ฌธ์์ด์ ๋ง๋ค ๋ ํน์ ๋ฌธ์์ด์ ํฌํจํ ๋ฌธ์์ด์ ์ ์ธ์ํค๋ ค๊ณ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ฌธ์์ด ๋ฆฌ์คํธ ["abc", "def", "ghi"]๊ฐ ์๊ณ ๋ฌธ์์ด "ef"๋ฅผ ํฌํจํ ๋ฌธ์์ด์ ์ ์ธํ๊ณ ๊ผฌ๋ฆฌ ๋ฌธ์์ด์ ๋ง๋ค๋ฉด "abcghi"๊ฐ ๋ฉ๋๋ค. ๋ฌธ์์ด ๋ฆฌ์คํธ str_list์ ์ ์ธํ๋ ค๋ ๋ฌธ์์ด ex๊ฐ ์ฃผ์ด์ง ๋, str_list์์ ex๋ฅผ ํฌํจํ ๋ฌธ์์ด์ ์ ์ธํ๊ณ ๋ง๋ ๊ผฌ๋ฆฌ ๋ฌธ์์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 2 ≤ str_list์ ๊ธธ์ด ≤ 10 1 ≤ str_list์ ์์์ ๊ธธ์ด ≤ 10 1 ≤ ex์ ๊ธธ์ด ≤ ..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๊ธ์ ์ด์ด ๋ถ์ฌ ๋ฌธ์์ด ๋ง๋ค๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ๋ฌธ์์ด my_string๊ณผ ์ ์ ๋ฐฐ์ด index_list๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. my_string์ index_list์ ์์๋ค์ ํด๋นํ๋ ์ธ๋ฑ์ค์ ๊ธ์๋ค์ ์์๋๋ก ์ด์ด ๋ถ์ธ ๋ฌธ์์ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ my_string์ ๊ธธ์ด ≤ 1,000 my_string์ ์์๋ ์์๋ฌธ์๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. 1 ≤ index_list์ ๊ธธ์ด ≤ 1,000 0 ≤ index_list์ ์์ = 0 && index < my_string.length) { answer += my_string[index]; } } return answer } โ ์กฐ๊ธ ์ด๋ ค์ ๋น .. ๐ ๊ฒฐ๊ณผ๋ฅผ ๋ด์ ๋ณ์๋ฅผ ์ ์ธํด..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ํน์ ํ ๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก ๋ฐ๊พธ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด my_string๊ณผ ์์๋ฌธ์ 1๊ธ์๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด alp๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, my_string์์ alp์ ํด๋นํ๋ ๋ชจ๋ ๊ธ์๋ฅผ ๋๋ฌธ์๋ก ๋ฐ๊พผ ๋ฌธ์์ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ my_string์ ๊ธธ์ด ≤ 1,000 ๐ ํ์ด function solution(my_string, alp) { if (my_string.includes(alp)) { return my_string.replaceAll(alp,alp.toUpperCase()) } else { return my_string } } โ my_string์ด alp๋ฅผ ํฌํจํ๊ณ ์์ผ๋ฉด replaceAll..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ํ ์ผ ๋ชฉ๋ก ๐ ๋ฌธ์ ์ค๋ช ์ค๋ ํด์ผ ํ ์ผ์ด ๋ด๊ธด ๋ฌธ์์ด ๋ฐฐ์ด todo_list์ ๊ฐ๊ฐ์ ์ผ์ ์ง๊ธ ๋ง์ณค๋์ง๋ฅผ ๋ํ๋ด๋ boolean ๋ฐฐ์ด finished๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, todo_list์์ ์์ง ๋ง์น์ง ๋ชปํ ์ผ๋ค์ ์์๋๋ก ๋ด์ ๋ฌธ์์ด ๋ฐฐ์ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ todo_list์ ๊ธธ์ด 1 ≤ 100 2 ≤ todo_list์ ์์์ ๊ธธ์ด ≤ 20 todo_list์ ์์๋ ์์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. todo_list์ ์์๋ ๋ชจ๋ ์๋ก ๋ค๋ฆ ๋๋ค. finished[i]๋ true ๋๋ false์ด๊ณ true๋ todo_list[i]๋ฅผ ๋ง์ณค์์, false๋ ์์ง ๋ง์น์ง ๋ชปํ์์ ๋ํ๋ ๋๋ค. ์์ง ๋ง์น์ง ๋ชป..