๋ชฉ๋กํ๋ก๊ทธ๋๋จธ์ค (151)
๐ค ์์งlog ๐ค
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ฐฐ์ด์ ์์๋งํผ ์ถ๊ฐํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ฐ์ฐ ⊕๋ ๋ ์ ์์ ๋ํ ์ฐ์ฐ์ผ๋ก ๋ ์ ์๋ฅผ ๋ถ์ฌ์ ์ด ๊ฐ์ ๋ฐํํฉ๋๋ค. ์๋ฅผ ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค. 12 ⊕ 3 = 123 3 ⊕ 12 = 312 ์์ ์ ์ a์ b๊ฐ ์ฃผ์ด์ก์ ๋, a ⊕ b์ 2 * a * b ์ค ๋ ํฐ ๊ฐ์ returnํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๋จ, a ⊕ b์ 2 * a * b๊ฐ ๊ฐ์ผ๋ฉด a ⊕ b๋ฅผ return ํฉ๋๋ค. ๐ ์ ํ์กฐ๊ฑด 1 ≤ a, b { for (let i = 0; i < n; i++) { answer.push(n) } }) return answer } โ ..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ๋ ์์ ์ฐ์ฐ๊ฐ ๋น๊ตํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ฐ์ฐ ⊕๋ ๋ ์ ์์ ๋ํ ์ฐ์ฐ์ผ๋ก ๋ ์ ์๋ฅผ ๋ถ์ฌ์ ์ด ๊ฐ์ ๋ฐํํฉ๋๋ค. ์๋ฅผ ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค. 12 ⊕ 3 = 123 3 ⊕ 12 = 312 ์์ ์ ์ a์ b๊ฐ ์ฃผ์ด์ก์ ๋, a ⊕ b์ 2 * a * b ์ค ๋ ํฐ ๊ฐ์ returnํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๋จ, a ⊕ b์ 2 * a * b๊ฐ ๊ฐ์ผ๋ฉด a ⊕ b๋ฅผ return ํฉ๋๋ค. ๐ ์ ํ์กฐ๊ฑด 1 ≤ a, b 2 * a * b) { return Number(str) } else if (str === 2..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ฝ์ ๊ตฌํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, n์ ์ฝ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ด์ ๋ฐฐ์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ n ≤ 10,000 ๐ ํ์ด function solution(n) { const answer = [] for ( let i = 1; i
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ต๋๊ฐ ๋ง๋ค๊ธฐ (2) ๐ ๋ฌธ์ ์ค๋ช ์ ์ ๋ฐฐ์ด numbers๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. numbers์ ์์ ์ค ๋ ๊ฐ๋ฅผ ๊ณฑํด ๋ง๋ค ์ ์๋ ์ต๋๊ฐ์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด -10,000 ≤ numbers์ ์์ ≤ 10,000 2 ≤ numbers ์ ๊ธธ์ด ≤ 100 ๐ ํ์ด function solution(numbers) { const sort = numbers.sort((a,b)=> a - b) return Math.max(numbers[0]*numbers[1], numbers[numbers.length-1]*numbers[numbers.length-2]); } โ ๋ฐฐ์ด numbers๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ ํด์คํ Math.max( ) ..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - l๋ก ๋ง๋ค๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด myString์ด ์ฃผ์ด์ง๋๋ค. ์ํ๋ฒณ ์์์์ "l"๋ณด๋ค ์์๋ ๋ชจ๋ ๋ฌธ์๋ฅผ "l"๋ก ๋ฐ๊พผ ๋ฌธ์์ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ myString ≤ 100,000 myString์ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด์ ๋๋ค. ๐ ํ์ด function solution(myString) { let answer = ""; for ( let i = 0; i < myString.length; i++ ) { if ( myString[i] < "l") { answer += "l" } else { answer += myString[i] } } return answer } โ ์ ๋น๋ฐฐ์ด์ธ answ..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - A ๊ฐ์กฐํ๊ธฐ ๐ ๋ฌธ์ ์ค๋ช ๋ฌธ์์ด myString์ด ์ฃผ์ด์ง๋๋ค. myString์์ ์ํ๋ฒณ "a"๊ฐ ๋ฑ์ฅํ๋ฉด ์ ๋ถ "A"๋ก ๋ณํํ๊ณ , "A"๊ฐ ์๋ ๋ชจ๋ ๋๋ฌธ์ ์ํ๋ฒณ์ ์๋ฌธ์ ์ํ๋ฒณ์ผ๋ก ๋ณํํ์ฌ return ํ๋ solution ํจ์๋ฅผ ์์ฑํ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ myString์ ๊ธธ์ด ≤ 20 myString์ ์ํ๋ฒณ์ผ๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด์ ๋๋ค. ๐ ํ์ด function solution(myString) { const lower = myString.toLowerCase() return lower.replaceAll("a","A") } โ ์ ์ฒด๋ฅผ ์๋ฌธ์๋ก ๋ณ๊ฒฝํด์คํ ์๋ฌธ์ "a"๋ง ๋๋ฌธ์ "A"๋ก ๋ฐ๊พธ์ด ์ฃผ์๋ค. function solution(myString) { return..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - x ์ฌ์ด์ ๊ฐ์ ๐ ๋ฌธ์ ์ค๋ช ๋ฌธ์์ด myString์ด ์ฃผ์ด์ง๋๋ค. myString์ ๋ฌธ์ "x"๋ฅผ ๊ธฐ์ค์ผ๋ก ๋๋ด์ ๋ ๋๋ ์ง ๋ฌธ์์ด ๊ฐ๊ฐ์ ๊ธธ์ด๋ฅผ ์์๋๋ก ์ ์ฅํ ๋ฐฐ์ด์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ myString์ ๊ธธ์ด ≤ 100,000 myString์ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด์ ๋๋ค. ๐ ํ์ด function solution(myString) { const answer = []; const x = myString.split("x"); for (let i = 0; i < x.length; i++) { answer.push(x[i].length); } return answer; } โ "oxooxoxxox" ๋ผ๋ myStri..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - ์ํธ ํด๋ ๐ ๋ฌธ์ ์ค๋ช ๊ตฐ ์ ๋ต๊ฐ ๋จธ์ฑ์ด๋ ์ ์ ์ค ์ ๊ตฐ์ด ๋ค์๊ณผ ๊ฐ์ ์ํธ ์ฒด๊ณ๋ฅผ ์ฌ์ฉํ๋ค๋ ๊ฒ์ ์์๋์ต๋๋ค. ์ํธํ๋ ๋ฌธ์์ด cipher๋ฅผ ์ฃผ๊ณ ๋ฐ์ต๋๋ค. ๊ทธ ๋ฌธ์์ด์์ code์ ๋ฐฐ์ ๋ฒ์งธ ๊ธ์๋ง ์ง์ง ์ํธ์ ๋๋ค. ๋ฌธ์์ด cipher์ ์ ์ code๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ ํด๋ ๋ ์ํธ ๋ฌธ์์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 1 ≤ cipher์ ๊ธธ์ด ≤ 1,000 1 ≤ code ≤ cipher์ ๊ธธ์ด cipher๋ ์๋ฌธ์์ ๊ณต๋ฐฑ์ผ๋ก๋ง ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ๊ณต๋ฐฑ๋ ํ๋์ ๋ฌธ์๋ก ์ทจ๊ธํฉ๋๋ค. ๐ ํ์ด function solution(cipher, code) { const answer = []; for ( let i = code - 1; i ..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - 5๋ช ์ฉ ๐ ๋ฌธ์ ์ค๋ช ์ต๋ 5๋ช ์ฉ ํ์น๊ฐ๋ฅํ ๋์ด๊ธฐ๊ตฌ๋ฅผ ํ๊ธฐ ์ํด ์ค์ ์์๋ ์ฌ๋๋ค์ ์ด๋ฆ์ด ๋ด๊ธด ๋ฌธ์์ด ๋ฆฌ์คํธ names๊ฐ ์ฃผ์ด์ง ๋, ์์์ ๋ถํฐ 5๋ช ์ฉ ๋ฌถ์ ๊ทธ๋ฃน์ ๊ฐ์ฅ ์์ ์์๋ ์ฌ๋๋ค์ ์ด๋ฆ์ ๋ด์ ๋ฆฌ์คํธ๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๋ง์ง๋ง ๊ทธ๋ฃน์ด 5๋ช ์ด ๋์ง ์๋๋ผ๋ ๊ฐ์ฅ ์์ ์๋ ์ฌ๋์ ์ด๋ฆ์ ํฌํจํฉ๋๋ค. ๐ ์ ํ์กฐ๊ฑด 5 ≤ names์ ๊ธธ์ด ≤ 30 1 ≤ names์ ์์์ ๊ธธ์ด ≤ 10 names์ ์์๋ ์์ด ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ๐ ํ์ด function solution(names) { const answer = []; for ( let i = 0; i < names.length; i+= 5) { answer.p..
ํ๋ก๊ทธ๋๋จธ์ค Lv.0 - n๊ฐ ๊ฐ๊ฒฉ์ ์์๋ค ๐ ๋ฌธ์ ์ค๋ช ์ ์ ๋ฆฌ์คํธ num_list์ ์ ์ n์ด ์ฃผ์ด์ง ๋, num_list์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ๋ง์ง๋ง ์์๊น์ง n๊ฐ ๊ฐ๊ฒฉ์ผ๋ก ์ ์ฅ๋์ด์๋ ์์๋ค์ ์ฐจ๋ก๋ก ๋ด์ ๋ฆฌ์คํธ๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๐ ์ ํ์กฐ๊ฑด 5 ≤ num_list์ ๊ธธ์ด ≤ 20 1 ≤ num_list์ ์์ ≤ 9 1 ≤ n ≤ 4 ๐ ํ์ด function solution(num_list, n) { const answer = []; for ( let i = 0; i < num_list.length; i+= n ) { answer.push(num_list[i]) } return answer } โ num_list ๋ฐฐ์ด์ ์์ i๋ฅผ n๋งํผ ์ฆ๊ฐ์ํค๋ฉด์ ๋ฐ๋ณตํ์ฌ..