num1
๊ณผ num2
๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, num1
์ num2
๋ก ๋๋ ๊ฐ์ 1,000์ ๊ณฑํ ํ ์ ์ ๋ถ๋ถ์ return ํ๋๋ก soltuion ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.num1
โค 100num2
โค 100์
์ถ๋ ฅ ์ #1
num1
์ด 3, num2
๊ฐ 2์ด๋ฏ๋ก 3 / 2 = 1.5์ 1,000์ ๊ณฑํ๋ฉด 1500์ด ๋ฉ๋๋ค.
์
์ถ๋ ฅ ์ #2
num1
์ด 7, num2
๊ฐ 3์ด๋ฏ๋ก 7 / 3 = 2.33333...์ 1,000์ ๊ณฑํ๋ฉด 2333.3333.... ์ด ๋๋ฉฐ, ์ ์ ๋ถ๋ถ์ 2333์
๋๋ค.
์
์ถ๋ ฅ ์ #3
num1
์ด 1, num2
๊ฐ 16์ด๋ฏ๋ก 1 / 16 = 0.0625์ 1,000์ ๊ณฑํ๋ฉด 62.5๊ฐ ๋๋ฉฐ, ์ ์ ๋ถ๋ถ์ 62์
๋๋ค.
// 1. num1์ num2๋ก ๋๋๋ค.
// 2. ๋๋ ๊ฐ์ 1000์ ๊ณฑํ๋ค.
// 3. ๊ทธ ๊ฐ์ ์ ์ ๋ถ๋ถ์ ๊ตฌํ๋ค.
function solution(num1, num2) {
var answer = Math.floor(num1 / num2 * 1000);
return answer;
}
// ๐ Math.floor ๋์ parseInt๋ก ํด๋ ๊ฒฐ๊ณผ ๋์ผํ๊ฒ ๋์ค์ง๋ง
// ๊ณ์ฐ ๊ฒฐ๊ณผ๊ฐ ์ซ์๊ฐ ๋์์ผํ๋ Math.floor๊ฐ ๋ ์ ํฉํ๋ค๊ณ ์๊ฐํจ
// parseInt
// 1. number -> string
// 2. 10์ง์ ์ถ๋ก ์ ์ํด string ์ ๋๊ธ์๊ฐ 0x ๋ 0X ์ธ์ง ๋น๊ต
๐ Math.floor()
: ์ฃผ์ด์ง ์ซ์์ ๊ฐ๊ฑฐ๋ ์์ ์ ์ ์ค์์ ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ฐํํฉ๋๋ค.
๐ parseInt()
: ๋ฌธ์์ด ์ธ์๋ฅผ ํ์ฑํ์ฌ ํน์ ์ง์(์์ ์ง๋ฒ ์ฒด๊ณ์์ ๊ธฐ์ค์ด ๋๋ ๊ฐ)์ ์ ์๋ฅผ ๋ฐํํฉ๋๋ค.
num1
๊ณผ num2
๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๋ ์๊ฐ ๊ฐ์ผ๋ฉด 1 ๋ค๋ฅด๋ฉด -1์ retrunํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.num1
โค 10,000num2
โค 10,000์
์ถ๋ ฅ ์ ์ค๋ช
#1
num1
์ด 2์ด๊ณ num2
๊ฐ 3์ด๋ฏ๋ก ๋ค๋ฆ
๋๋ค. ๋ฐ๋ผ์ -1์ returnํฉ๋๋ค.
์
์ถ๋ ฅ ์ ์ค๋ช
#2
num1
์ด 11์ด๊ณ num2
๊ฐ 11์ด๋ฏ๋ก ๊ฐ์ต๋๋ค. ๋ฐ๋ผ์ 1์ returnํฉ๋๋ค.
์
์ถ๋ ฅ ์ ์ค๋ช
#3
num1
์ด 7์ด๊ณ num2
๊ฐ 99์ด๋ฏ๋ก ๋ค๋ฆ
๋๋ค. ๋ฐ๋ผ์ -1์ returnํฉ๋๋ค.
// 1. ๋ ์๊ฐ ๊ฐ์์ง ๋น๊ต
// 2. ๊ฒฐ๊ณผ ๊ฐ์ ๋ฐ๋ผ 1 ๋๋ -1 ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ (if๋ฌธ)
function solution(num1, num2) {
if ( num1 === num2 ) {
return 1;
} else {
return -1;
}
}
๐ if
if (true/false) {
// true ์ผ๋ ์คํ๋ ์ฝ๋
}
๐ if...else
if (true/false) {
// true ์ผ๋ ์คํ๋ ์ฝ๋
} else {
// false ์ผ๋ ์คํ๋ ์ฝ๋
}
๐ if...else
: ์ง์ ํ ์กฐ๊ฑด์ด ์ฐธ์ธ ๊ฒฝ์ฐ ๋ช
๋ น๋ฌธ(statement)์ ์คํํฉ๋๋ค. ์กฐ๊ฑด์ด ๊ฑฐ์ง์ธ ๊ฒฝ์ฐ ๋ ๋ค๋ฅธ ๋ช
๋ น๋ฌธ์ด ์คํ ๋ ์ ์์ต๋๋ค.
numer1
, denom1
, ๋ ๋ฒ์งธ ๋ถ์์ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ๋ปํ๋ numer2
, denom2
๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๋ ๋ถ์๋ฅผ ๋ํ ๊ฐ์ ๊ธฐ์ฝ ๋ถ์๋ก ๋ํ๋์ ๋ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ์์๋๋ก ๋ด์ ๋ฐฐ์ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์.numer1
, denom1
, numer2
, denom2
< 1,000์
์ถ๋ ฅ ์ #1
1 / 2 + 3 / 4 = 5 / 4์
๋๋ค. ๋ฐ๋ผ์ [5, 4]๋ฅผ return ํฉ๋๋ค.
์
์ถ๋ ฅ ์ #2
9 / 2 + 1 / 3 = 29 / 6์
๋๋ค. ๋ฐ๋ผ์ [29, 6]์ return ํฉ๋๋ค.
// 1. ๋ถ๋ชจ๋ง์
// 2. ๋ถ์,๋ถ๋ชจ์ ์ต๋๊ณต์ฝ์๋ก ๋๋ ์ค
// 2-1. ๋ถ์,๋ถ๋ชจ ์ค ์์ ์๋ฅผ ์ฐพ๊ธฐ
// 2-2. ์์์๋ฅผ ๋ถ์,๋ถ๋ชจ ๋๋ ๋ณด๊ธฐ
// 2-2-1. ๋๋ค ๋๋์ด ๋จ์ด์ง๋ฉด ๊ทธ ๋๋ ์๊ฐ ์ต๋๊ณต์ฝ์
// 2-2-2. ์ ๋๋์ด ๋จ์ด์ง๋ฉด ์์ ์๋ฅผ 1๋ก ์ค์ด๊ณ 2-2.๋ก ๋์๊ฐ๊ธฐ
function solution(numer1, denom1, numer2, denom2) {
var answer = [];
const numer = numer1 * denom2 + numer2 * denom1;
const denom = denom1 * denom2;
let minNumber;
if (denum < num) {
minNumber = denum;
} else {
minNumber = num;
}
// ๋๋์ด ๋จ์ด์ง๋ ๊ฒ โ ๋๋จธ์ง๊ฐ 0์ธ ๊ฒ
while (true) {
if (denum % minNumber === 0) {
if (num % minNumber === 0) {
return [denum / minNumber, num / minNumber];
}
}
minNumber = minNumber - 1;
// minNumber ์๋ ์์ ์๊ฐ ๋ค์ด๊ฐ ์์
}
return answer;
}
๐ while
while (true) {
// true์ธ ๋์ ๊ณ์ ๋ฐ๋ณต ์คํ
}
// false ์ผ๋ ๋น ์ ธ๋๊ฐ
๐ while
: ์กฐ๊ฑด๋ฌธ์ด ์ฐธ์ผ ๋ ์คํ๋๋ ๋ฐ๋ณต๋ฌธ์ด๋ค. ์กฐ๊ฑด์ ๋ฌธ์ฅ์์ด ์คํ๋๊ธฐ ์ ์ ์ฐธ, ๊ฑฐ์ง์ ํ๋จํ๋ค.
numbers
๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. numbers
์ ๊ฐ ์์์ ๋๋ฐฐํ ์์๋ฅผ ๊ฐ์ง ๋ฐฐ์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.numbers
์ ์์ โค 10,000numbers
์ ๊ธธ์ด โค 1,000์
์ถ๋ ฅ ์ #1
[1, 2, 3, 4, 5]์ ๊ฐ ์์์ ๋๋ฐฐ๋ฅผ ํ ๋ฐฐ์ด [2, 4, 6, 8, 10]์ returnํฉ๋๋ค.
์
์ถ๋ ฅ ์ #2
[1, 2, 100, -99, 1, 2, 3]์ ๊ฐ ์์์ ๋๋ฐฐ๋ฅผ ํ ๋ฐฐ์ด [2, 4, 200, -198, 2, 4, 6]์ returnํฉ๋๋ค.
// 1. numbers์์ ์์๋ฅผ ๊บผ๋ด์ผํจ.
// 2. ์์๋ฅผ ๊บผ๋ด 2๋ฐฐ๋ฅผ ํ ํ ์ ๋ฐฐ์ด์ ๋ฃ์ด์ค์ผํจ.
// numbers [1,2,3,4,5]
// numbers [0]
// answer.push(); method ์ฌ์ฉ
// push ํ์ ? ๋ฐฐ์ด์ ๊ธธ์ด ๋งํผ
๐ while
function solution(numbers) {
var answer = [];
let cnt = 0;
while(cnt < numbers.length) {
answer.push(numbers[cnt] * 2);
cnt = cnt + 1;
}
return answer;
}
๐ for
function solution(numbers) {
var answer = [];
for (let cnt = 0; cnt < numbers.lengths; cnt = cnt + 1) {
answer.push(numbers[cnt] * 2);
}
return answer;
}