ํ์ ๊ณต๋ถ (151) ์ธ๋ค์ผํ ๋ฆฌ์คํธํ [ํ๋ก๊ทธ๋๋จธ์ค level.0] 9๋ก ๋๋ ๋๋จธ์ง function solution(number) { return number.split("").reduce((a, b) => Number(a) + Number(b))%9; } function solution(number) { const nums = number.split(""); let sum = 0; for (let i = 0; i < nums.length; i++) { sum += Number(nums[i]) } return sum % 9 } ๊ถ๊ธํด์ ์๋ ๋น๊ตํด๋ดค๋๋ฐ for ๋ฌธ ์ด์ฉํ๊ฒ ๋ ์ ๊ฒ ๊ฑธ๋ฆฐ๋ค. ๊ทธ๋ฆฌ๊ณ ๋จ์ํ๊ฒ 2๋ก ๋๋ ๋๋จธ์ง ์ถ๋ ฅํ๋ ค๊ณ ํ๋๊น ์๋ผ์ ์๊ฐํด๋ณด๋, ์ซ์๋ก ๋ํ๋ผ ์ ์๋ ๋ฒ์๊ฐ ์์๋ค. ๊ทธ๋์ BigInt ๋ฅผ ์ด์ฉํด์ ์ถ๋ ฅํด๋ณด๋, n ์ ๋ถ์ด๊ณ ์ถ๋ ฅ๋๋ค. Number ์ ๋ฉ.. [ํ๋ก๊ทธ๋๋จธ์ค level.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 function solution(a, b) { return Number('' + a + b) > 2 * a * b ? Number('' + a + b) : 2 * a * b ; } ํ์ด 2 function solution(a, b) { return Math.max(Number('' + a + b), 2 * a * b ) } ๋๊ฐ์ง ๋ฐฉ๋ฒ.. [ํ๋ก๊ทธ๋๋จธ์ค level.1] ์์ฐ์ ๋ค์ง์ด ๋ฐฐ์ด๋ก ๋ง๋ค๊ธฐ function solution(n) { return String(n).split("").reverse().map(v=> Number(v)); } ๊ฐ์ฅ ๋จ์ํ๊ฒ ์๊ฐ๋์ ์ด๋ ๊ฒ ํ์๋๋ฐ, ์๋๋ฉด์์ ์ข์ ์ฝ๋๋ ์๋ ๊ฒ ๊ฐ๋ค. ์์ฐ์ n์ ๋ค์ง์ด ๊ฐ ์๋ฆฌ ์ซ์๋ฅผ ์์๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ํํ๋ก ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ๋ค์ด n์ด 12345์ด๋ฉด [5,4,3,2,1]์ ๋ฆฌํดํฉ๋๋ค. n์ 10,000,000,000์ดํ์ธ ์์ฐ์์ ๋๋ค. ๋๋ ๋น์ฐํ 0์ด ์์ฐ์๊ฐ ์๋๋๊น ๊ณ ๋ ค ์ํ๋๋ฐ, ์ด์ฐ์ํ(?) ์์๋ 0์ด ํฌํจ๋๋ ๊ฒฝ์ฐ๋ ์๋ค๊ณ ํ๋ค. ๊ทธ์น๋ง ์ด์ฐ์ํ์ด ๋ ์์ธ์ ์ธ ๊ฒฝ์ฐ๋๊น 0์ด ํฌํจ๋๋ ๋ฒ์๋ผ๋ ๋ง์ด ์๋ค๋ฉด ์ผ๋ฐ ์ํ์ผ๋ก ์๊ฐํด์ผ๊ฒ ๋ค! + ํ ํ์ดํ ํจ์์์ ์ธ์๋ ๋ฉ์๋๊ฐ ๋ฐ๋ ์ธ์๋ ๊ฐ์ ๋ ์๋ต์ด ๊ฐ๋ฅํ๊ฑฐ๋ .. [์๊ณ ๋ฆฌ์ฆ || ํ๋ก๊ทธ๋๋จธ์ค] x๋งํผ ๊ฐ๊ฒฉ์ด ์๋ n๊ฐ์ ์ซ์ ์ฒ๋ฆฌ ์๋์ ๋ํด ์ธ์ง๋ฅผ ํ๊ฒ ๋์ด ์ค๋์ ์๋๋ ๋น๊ตํด ๋ดค๋ค. function solution(x, n) { return new Array(n).fill(x).map((v, i) => v += x * i) } ์ฒ์์ ์ด๋ ๊ฒ ํ์๋๋ฐ, ๊ฐ์ฅ ๋น ๋ฅธ ์๋๋ 0.04ms ๊ฐ ๋์๋ค. ๊ทธ ๋ค์์ ํ ๋ฐฉ๋ฒ์ function solution(x, n) { let result = []; for (let i = 0; i < n; i++) { result.push(x + x * i) } return result; } ์ด๋ ๊ฒ for ๋ฌธ์ ๋๋ฆฐ ๋ฐฉ๋ฒ์ธ๋ฐ, ๊ฐ์ฅ ์๋๊ฐ 0.03ms ์ด ๋์๋ค. ํฐ ์ฐจ์ด๋ ์์ง๋ง, ๋์ฒด๋ก for ๋ฌธ์ด ๋ ๋น ๋ฅด๊ฒ ๋์๋ค. [์๊ณ ๋ฆฌ์ฆ || ํ๋ก๊ทธ๋๋จธ์ค] ๋๋จธ์ง๊ฐ 1์ด ๋๋ ์ ์ฐพ๊ธฐ + ๐ ๊ณ ์์ ํ์ด๋ฒ https://school.programmers.co.kr/learn/courses/30/lessons/87389 ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์. programmers.co.kr function solution(n) { for (let i = 0; i < n; i++) { if (n % i === 1) { return i; } } } ๋จ์ํ ๋์ ํ์ด. ์๋ง ์๊ณ ๋ฆฌ์ฆ ์คํฐ๋๋ฅผ ์ํ๋๋ผ๋ฉด ์ ํ ์ค ์๊ณ ๊ทธ๋ฅ ๋์ด๊ฐ๊ฒ ์ง..! 1. ์ด๋ป๊ฒ๋ ํ์ด๋ณธ๋ค. 2. ๋ง์ถ๋ค. 3. ๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ์ฐธ๊ณ ํด ๋ชจ๋ฅด๋ ๋ฐฉ์, ์ฐธ๊ณ ํ ๋งํ ๋ฐฉ์, ๋ฉ์๋ ๋ฑ์ ๊ณต๋ถํ๋ค. 4. ๋ค๋ฅธ ๋ฌธ์ ๋ฅผ ํผ๋ค.. [ํ๋ก๊ทธ๋๋จธ์ค/Javascript/์ฝ๋ฉ๊ธฐ์ดํธ๋ ์ด๋] A ๊ฐ์กฐํ๊ธฐ function solution(myString) { return [...myString].map(v => v === "a" || v === "A" ? "A" : v.toLowerCase()).join(""); } ์ฒ์์ "A" -> "A" ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ์ง ์์์ ํต๊ณผ๋์ง ์์๋ค. "A" ๊ฐ "a" ๊ฐ ๋์ด๋ฒ๋ฆผ. ๊ทผ๋ฐ map ์์์ v === "a" || "A" ? ์ด๋ ๊ฒ ์จ์ ๋ ํต๊ณผ๋์ง ๋ชปํ๋ค. ์ด๋ ๊ฒ ์ฐ๋ฉด v๋ "a" ์ธ ๊ฒฝ์ฐ์ ๊ทธ๋ฅ "A"๊ฐ ์๋ ์ํฉ์ด์ง , v ๊ฐ "a" ๋๋ v๊ฐ "A" ์ผ ๋ ๋๊ฐ์ง ํ๊ฐ๊ฐ ๋์ง ์๋๋ค. ๊ฐ๋ ์ฐฉ๊ฐํด์ ์ด๋ ๊ฒ ์๋ชป์ด๋ค..!! boolean ๊ฐ์ผ๋ก ํ๊ฐํด์ผํ ๋ ๊ผญ ์ ์ํ๊ธฐ. ์๋ ์ฝ๋๋ ๋ค๋ฅธ ์ฌ๋์ ์ฝ๋ ์ค ๊น๋ํด๋ณด์ด๋ฉด์, ์๋ณด๋ ๋ฐฉ์์ด๋ผ ๊ฐ์ ธ์๋ค. funct.. [ํ๋ก๊ทธ๋๋จธ์ค/Javascript/์ฝ๋ฉ๊ธฐ์ดํธ๋ ์ด๋] ๋ฐฐ์ด์ ๊ธธ์ด์ ๋ฐ๋ผ์ ๋ค๋ฅธ ์ฐ์ฐ ํ๊ธฐ ๋ด๊ฐ ์ ์ถํ ๋ฐฉ์. function solution(arr, n) { return arr.length % 2 === 1 ? arr.map((v, i) => i % 2 === 0 ? v + n : v) : arr.map((v, i) => i % 2 === 1 ? v + n : v)} ํต๊ณผ๋ ํ์ง๋ง, ์ฝ๋๊ฐ ๋๋ฌด ๊ธธ๊ณ ๋ฐ๋ณต๋๋ ๋ถ๋ถ๋ ๋ง๋ค. ๋ฌธ์ ๋ฅผ ๊ทธ๋๋ก ์จ์ ๊ทธ๋ ๋ค. ์๋์ฒ๋ผ ๋ฌธ์ ๋ฅผ ๊ฐ๊ฒฐํ ์์ผ์ ์กฐ๊ฑด๊ณผ ์ถ๋ ฅ๊ฐ์ ์ค์ ํด์ฃผ๋ ๋ฐฉ๋ฒ์ด ๊ฐ๋ ์ฑ์ด ์ข๋ค. const solution = (arr, n) => arr.map((num, idx) => ( arr.length % 2 !== idx % 2 ? num + n : num )) ๋ฐฐ์ด์ ๊ธธ์ด์ index ์ ๊ธธ์ด๋ฅผ ์ผ์น ์ํด. (ํ์์ผ ๋ -> ํ์ index, ์ง.. [ํ๋ก๊ทธ๋๋จธ์ค/Javascript/์ฝ๋ฉ๊ธฐ์ดํธ๋ ์ด๋] ์ ๋ฏธ์ฌ์ธ์ง ํ์ธํ๊ธฐ function solution(my_string, is_suffix) { return my_string.slice(- is_suffix.length) === is_suffix ? 1 : 0; } ์ด๋ ๊ฒ ์ฃผ์ด์ง ๋ฌธ์์ length ๋ฅผ ์ด์ฉํด์ ํ์๋๋ฐ, string.endsWith() ๋ผ๋๊ฒ ์์๋ค. String.prototype.endsWith() https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith String.prototype.endsWith() - JavaScript | MDN The endsWith() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ค ๋ฌธ์์ด์์ ํน์ ๋ฌธ์์ด๋ก ๋๋๋์ง๋ฅผ ํ์ธํ ์ ์์ผ๋ฉฐ, ๊ทธ.. ์ด์ 1 ยทยทยท 6 7 8 9 10 11 12 ยทยทยท 19 ๋ค์