๋ชฉ๋กJavaScript (140)
๐ค ์์งlog ๐ค
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ฌธ์์ด ์ ์์ ํฉ ๐ ๋ฌธ์ ์ค๋ช ํ ์๋ฆฌ ์ ์๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด num_str์ด ์ฃผ์ด์ง ๋, ๊ฐ ์๋ฆฌ์์ ํฉ์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 3 ≤ num_str ≤ 100 ๐ ํ์ด function solution(num_str) { let answer = 0; const arr = Array.from(num_str) for ( let i = 0; i < arr.length; i++) { answer += Number(arr[i]) } return answer } โ ๋ฌธ์์ด์ ๋ฐฐ์ด๋ก ๋ฐ๊พผํ ๊ฐ ์์๋ค์ ๋ํ๋ฉด๋๋ค๊ณ ์๊ฐํ๋ค. Array.from์ผ๋ก ๋ฌธ์์ด์ ๋ฐฐ์ด๋ก ๋ฐ๊ฟ์ค๋ค for๋ฌธ์ผ๋ก answer์ ์ซ์๋ก ๋ฐ๊พผ ๊ฐ ์์๋ค์ ๋ํด์ฃผ์๋ค. ๐ก Ar..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ฒซ ๋ฒ์งธ๋ก ๋์ค๋ ์์ ๐ ๋ฌธ์ ์ค๋ช ์ ์ ๋ฆฌ์คํธ num_list๊ฐ ์ฃผ์ด์ง ๋, ์ฒซ ๋ฒ์งธ๋ก ๋์ค๋ ์์์ ์ธ๋ฑ์ค๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์์๊ฐ ์๋ค๋ฉด -1์ returnํฉ๋๋ค. ๐ ์ ํ์กฐ๊ฑด 5 ≤ num_list์ ๊ธธ์ด ≤ 100 -10 ≤ num_list์ ์์ ≤ 100 ๐ ํ์ด function solution(num_list) { for ( let i = 0; i < num_list.length; i++) { if(num_list[i] < 0){ return i } } return -1 } โ for()๋ฌธ์ผ๋ก num_list๋ฅผ ๋ฐ๋ณตํํ num_list[i]๊ฐ 0๋ณด๋ค ์์ ์ซ์๊ฐ ์์ผ๋ฉด i (index = ๋ช๋ฒ์งธ์ธ์ง)๋ฅผ ๋ฐํํ๊ณ ์์ผ๋ฉด -1์ ..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - n ๋ฒ์งธ ์์๋ถํฐ ๐ ๋ฌธ์ ์ค๋ช ์ ์ ๋ฆฌ์คํธ num_list์ ์ ์ n์ด ์ฃผ์ด์ง ๋, n ๋ฒ์งธ ์์๋ถํฐ ๋ง์ง๋ง ์์๊น์ง์ ๋ชจ๋ ์์๋ฅผ ๋ด์ ๋ฆฌ์คํธ๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 2 ≤ num_list์ ๊ธธ์ด ≤ 30 1 ≤ num_list์ ์์ ≤ 9 1 ≤ n ≤ num_list์ ๊ธธ์ด ๐ ํ์ด function solution(num_list, n) { return num_list.slice(n -1 ) } โ slice() ๋ฉ์๋ ์ฌ์ฉํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํด์ (n) ๋ง ๋ฃ์๋๋ n๋ฒ์งธ๋ ํฌํจ์ด ์๋์ด์ -1 ํด์ฃผ์๋ค. : n๋ถํฐ ์์ํ๋ ๋ฐฐ์ด์ ์ผ๋ถ๋ฅผ ์ถ์ถํ๋ ค๋ฉด n - 1์ ์ฌ์ฉํ์ฌ 0๋ถํฐ ์์ํ๋ ์ธ๋ฑ์ฑ์ ์กฐ์ ํด์ผ ํ๋ค. ๐ก slice ๋ฉ์..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - flag์ ๋ฐ๋ผ ๋ค๋ฅธ ๊ฐ ๋ฐํํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ๋ ์ ์ a, b์ boolean ๋ณ์ flag๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, flag๊ฐ true๋ฉด a + b๋ฅผ false๋ฉด a - b๋ฅผ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด -1,000 ≤ a, b ≤ 1,000 ๐ ํ์ด function solution(a, b, flag) { if(flag === true) { return a + b } else { return a - b } } โ if() ๋ฌธ์ ์ฌ์ฉํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๊ณ , flag๊ฐ === true๋ฉด a+b, true๊ฐ ์๋๋ฉด a-b๋ฅผ ๋ฆฌํดํ๊ฒํ๋ค.
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ ์ ์ฐพ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ ์ ๋ฆฌ์คํธ num_list์ ์ฐพ์ผ๋ ค๋ ์ ์ n์ด ์ฃผ์ด์ง ๋, num_list์์ n์ด ์์ผ๋ฉด 1์ ์์ผ๋ฉด 0์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 3 ≤ num_list์ ๊ธธ์ด ≤ 100 1 ≤ num_list์ ์์ ≤ 100 1 ≤ n ≤ 100 ๐ ํ์ด function solution(num_list, n) { if(num_list.includes(n)){ return 1 } else { return 0 } } โ ๋ฐฐ์ด/ ๋ฌธ์์ด์ ํน์ ๊ฐ์ด ํฌํจ๋์ด์๋์ง ํ๋จํ๋ includes() ์ฌ์ฉํด์ 1 / 0์ ๋ฆฌํดํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. ๐ก includes() ๋ฉ์๋๋ ๋ฐฐ์ด์ ํญ๋ชฉ์ ํน์ ๊ฐ์ด ํฌํจ๋์ด ์๋์ง๋ฅผ ํ๋จํ์ฌ ์ ์ ํ..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ ๊ณฑ์ ํ๋ณํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ด๋ค ์์ฐ์๋ฅผ ์ ๊ณฑํ์ ๋ ๋์ค๋ ์ ์๋ฅผ ์ ๊ณฑ์๋ผ๊ณ ํฉ๋๋ค. ์ ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, n์ด ์ ๊ณฑ์๋ผ๋ฉด 1์ ์๋๋ผ๋ฉด 2๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ n ≤ 1,000,000 ๐ ํ์ด function solution(n) { let x = Math.sqrt(n) if (x % 1 === 0) { return 1 } else { return 2 } } โ ์ ๊ณฑ์์ธ์ง ํ๋ณ๋ถํฐ ํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. ๊ฒ์ํด๋ณด๋ Math.sqrt() ํจ์๋ก ์ ๊ณฑ์๋ฅผ ์ฐพ์์ ์๋ค๋๊ฒ์ ์๊ฒ๋์๊ณ Math.sqrt(n)์ผ๋ก n์ ์ ๊ณฑ๊ทผ์ x๋ผ๋ ๋ณ์์ ๋ด์๋๋ค, ์กฐ๊ฑด๋ฌธ์ผ๋ก x๊ฐ ์ ์์ธ์ง ํ๋ณํ๋ค. ์ ๊ณฑ์๊ฐ ์๋๋ผ๋ฉด ์์๊ฐ ๋..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ฌธ์์ด ๊ณฑํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ๋ฌธ์์ด my_string๊ณผ ์ ์ k๊ฐ ์ฃผ์ด์ง ๋, my_string์ k๋ฒ ๋ฐ๋ณตํ ๋ฌธ์์ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ my_string์ ๊ธธ์ด ≤ 100 my_string์ ์์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. 1 ≤ k ≤ 100 ๐ ํ์ด function solution(my_string, k) { return my_string.repeat(k) } โ ์ ๋ฒ์ ๋ฌธ์์ด ๋ฐ๋ณต์ถ๋ ฅํ๋ ๋ฌธ์ ์์ ์ฌ์ฉํ repeat() ๋ฉ์๋ ์ฌ์ฉํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. ๐ก repeat() ๋ฉ์๋๋ ๋ฌธ์์ด์ ์ฃผ์ด์ง ํ์๋งํผ ๋ฐ๋ณตํด ๋ถ์ธ ์๋ก์ด ๋ฌธ์์ด์ ๋ฐํํฉ๋๋ค. str.repeat(count); count => ๋ฌธ์์ด์ ๋ฐ๋ณตํ ํ์...
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ํ์ง์ ๋ฐ๋ผ ๋ค๋ฅธ ๊ฐ ๋ฐํํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์์ ์ ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, n์ด ํ์๋ผ๋ฉด n ์ดํ์ ํ์์ธ ๋ชจ๋ ์์ ์ ์์ ํฉ์ return ํ๊ณ n์ด ์ง์๋ผ๋ฉด n ์ดํ์ ์ง์์ธ ๋ชจ๋ ์์ ์ ์์ ์ ๊ณฑ์ ํฉ์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ n ≤ 100 ๐ ํ์ด function solution(n) { let answer = 0; if (n % 2 === 1) { for ( let i = 1; i
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ ์ ๋ถ๋ถ ๐ ๋ฌธ์ ์ค๋ช ์ค์ flo๊ฐ ๋งค๊ฐ ๋ณ์๋ก ์ฃผ์ด์ง ๋, flo์ ์ ์ ๋ถ๋ถ์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 0 ≤ flo ≤ 100 ๐ ํ์ด function solution(flo) { let answer = Math.floor(flo) return answer; } โ ์์์ ์ดํ ์ซ์๋ ๋ฒ๋ฆฌ๊ณ ์ ์๋ง ๋ฐํํ๋ฉด ๋๋๊ฑฐ ๊ฐ์์ Math.floor() ์ฌ์ฉํ์๋ค. ๐กMath.floor() ํจ์๋ ์ฃผ์ด์ง ์ซ์์ ์์ซ์ ์๋ฆฌ๋ฅผ ์๋ผ๋ฒ๋ฆฌ๊ณ , ๊ทธ ์ซ์ ์ดํ์ ๊ฐ์ฅ ํฐ ์ ์๋ฅผ ๋ฐํํ๋ ํจ์.
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ ์กฐ์ํ๊ธฐ 1 ๐ ๋ฌธ์ ์ค๋ช ์ ์ n๊ณผ ๋ฌธ์์ด control์ด ์ฃผ์ด์ง๋๋ค. control์ "w", "a", "s", "d"์ 4๊ฐ์ ๋ฌธ์๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, control์ ์์์๋ถํฐ ์์๋๋ก ๋ฌธ์์ ๋ฐ๋ผ n์ ๊ฐ์ ๋ฐ๊ฟ๋๋ค. "w" : n์ด 1 ์ปค์ง๋๋ค. "s" : n์ด 1 ์์์ง๋๋ค. "d" : n์ด 10 ์ปค์ง๋๋ค. "a" : n์ด 10 ์์์ง๋๋ค. ์ ๊ท์น์ ๋ฐ๋ผ n์ ๋ฐ๊ฟจ์ ๋ ๊ฐ์ฅ ๋ง์ง๋ง์ ๋์ค๋ n์ ๊ฐ์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด -100,000 ≤ n ≤ 100,000 1 ≤ control์ ๊ธธ์ด ≤ 100,000 control์ ์ํ๋ฒณ ์๋ฌธ์ "w", "a", "s", "d"๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด์ ๋๋ค. ๐ ํ์ด funct..