๐ ์ด์ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ์ด์ ํจ๊ป ํธ๋ ์๊ฐ์ด์๋๋ฐ 1~3๋ฒ์ธ ๊ทธ๋ฆฌ๋, ๊ตฌํ ๋ฌธ์ ๋ ํ์์ผ๋ 4๋ฒ์ธ DP ๋ฌธ์ ๋ฅผ ํ์ง ๋ชปํ์๋ค ์กฐ๊ธ๋ง ๋ ์๊ฐํ์ผ๋ฉด ํ์๊ฒ ์ง๋ผ๋ ์๊ฐ๋ ๋ค์์ผ๋ ๊ทธ๊ฒ์ ์ฝ๋ฉํ ์คํธ๋ก ๋ฐ์ง๋ ์๊ฐ์ด ๋ง์ด ๊ฑธ๋ ธ๊ธฐ ๋๋ฌธ์ 1์ ์ ๋์ ํ์ด๊ฐ ๋์ง ๋ชปํ์ ๊ฒ ๊ฐ๋ค. ์์ผ๋ก JS๋ก ์๊ณ ๋ฆฌ์ฆ์ ๋์ฑ ๋ง์ด ํ์ด์ผ ๊ฒ ๋ค๋ ์๊ฐ์ ํ๊ฒ๋์๋ ํ๋ฃจ์๋ค. ๊ทธ๋์ ์ค๋์ ๊ผญ ๋ชจ๋ ๋ฌธ์ ๋ฅผ ํ์ด์ ๊ฐ์ด ํด๊ฒฐํ ์ ์์์ผ๋ฉด ์ข๊ฒ ๋ค๋ ์๊ฐ์ ํ๋ค.
๐ ์ค๋ ํ์ตํ ๋ด์ฉ
์์ด (Permutaion)
- ์๋ก ๋ค๋ฅธ n๊ฐ์ ์์๋ฅผ ๊ฐ์ง๋ ์ด๋ค ์งํฉ์์ ์ค๋ณต ์์ด ์์์ ์๊ด์๊ฒ r๊ฐ์ ์์๋ฅผ ์ ํํ๊ฑฐ๋ ํน์ ๋์ดํ๋ ๊ฒ์ด๋ฉฐ, ์ด๋ ์กฐํฉ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก n๊ฐ์ ์์๋ก ์ด๋ฃจ์ด์ง ์งํฉ์์ r๊ฐ์ ์์๋ก ์ด๋ฃจ์ด์ง ๋ถ๋ถ์งํฉ์ ๋ง๋๋ ๊ฒ๊ณผ ๊ฐ๋ค.
์กฐํฉ (Combination)
- ์๋ก ๋ค๋ฅธ n๊ฐ์ ์์๋ฅผ ๊ฐ์ง๋ ์ด๋ค ์งํฉ์์ ์ค๋ณต ์์ด ์์์ ์๊ด์๊ฒ r๊ฐ์ ์์๋ฅผ ์ ํํ๋ ๊ฒ์ด๋ฉฐ, ์ด๋ n๊ฐ์ ์์๋ก ์ด๋ฃจ์ด์ง ์งํฉ์์ r๊ฐ์ ์์๋ก ์ด๋ฃจ์ด์ง ๋ถ๋ถ์งํฉ์ ๋ง๋๋ ๊ฒ๊ณผ ๊ฐ๋ค.
GCD (์ต๋๊ณต์ฝ์, Greatest Common Divisor)
- ๋ ์ ์ด์์ ์ฌ๋ฌ ์ ์ค ๊ณตํต๋ *์ฝ์๋ฅผ ์๋ฏธํ๋ค.
- *์ฝ์: ์ด๋ค ์๋ฅผ ๋๋์ด ๋จ์ด์ง๊ฒ ํ๋ ์๋ฅผ ์๋ฏธํ๋ค.
- ์์
- 6์ ์ฝ์: 1, 2, 3, 6
- 9์ ์ฝ์: 1, 3, 9
- ๊ณต์ฝ์: 1, 3
- ์ต๋ ๊ณต์ฝ์: 3
LCM (์ต์๊ณต๋ฐฐ์, Lowest Common Multiple)
- ๊ณต๋ฐฐ์๋ ๋ ์ ์ด์์ ์ฌ๋ฌ ์ ์ค ๊ณตํต๋ ๋ฐฐ์๋ฅผ ์๋ฏธํ๋ค.
- *๋ฐฐ์: ํ๋์ ์์ ์ ์๋ฅผ ๊ณฑํ ์ ์ด๋ค.
- ์์
- 12์ ๋ฐฐ์: 12, 24, 36, 48, 60, 72, 84, 96 ...
- 18์ ๋ฐฐ์: 18, 36, 54, 72, 90 ...
- ์ต์ ๊ณต๋ฐฐ์: 36
GCD/LCM ๊ตฌํ๋ ๊ณต์
- ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ
- ์ต๋ ๊ณต์ฝ์์ ๊ด๋ จ์ด ๊น์ ๊ณต์์ด๋ค. 2๊ฐ์ ์์ฐ์ a์ b๊ฐ ์์ ๋, a๋ฅผ b๋ก ๋๋ ๋๋จธ์ง๋ฅผ r์ด๋ผ ํ๋ฉด a์ b์ ์ต๋ ๊ณต์ฝ์๋ b์ r์ ์ต๋ ๊ณต์ฝ์์ ๊ฐ๋ค๋ ์ด๋ก ์ด๋ค.
- b๋ฅผ r๋ก ๋๋ ๋๋จธ์ง r'๋ฅผ ๊ตฌํ๊ณ , ๋ค์ r์ r'๋ก ๋๋๋ ๊ณผ์ ์ ๋ฐ๋ณตํด, ๋๋จธ์ง๊ฐ 0์ด ๋์์ ๋ ๋๋๋ ์๊ฐ a์ b์ ์ต๋ ๊ณต์ฝ์์ด๋ค.
let getGCD = (num1, num2) => {
let gcd = 1;
for (let i = 2; i <= Math.min(num1, num2); i++){
if(num1 % i === 0 && num2 % i === 0){
gdc = i;
}
}
}
/*----------------------------------------------*/
let gcd=(a,b) => {
return a%b ? gcd(b, a%b) : b
}
- ์ต๋ ๊ณต์ฝ์(GCD)
- ๋ ์ A์ B์ ๊ณตํต๋ ์ฝ์ ์ค์ ๊ฐ์ฅ ํฐ ์ ์
- 2๋ถํฐ min(A, B)๊น์ง ๋ชจ๋ ์ ์๋ก ๋๋์ด๋ณด๋ ๋ฐฉ๋ฒ
let getGCD = (num1, num2) => {
let gcd = 1;
for (let i = 2; i <= Math.min(num1, num2); i++){
if(num1 % i === 0 && num2 % i === 0){
gdc = i;
}
}
return gcd
}
- ์ต์ ๊ณต๋ฐฐ์(LCM)
- ๋ ์, ๊ทธ ์ด์์ ์ฌ๋ฌ ์์ ๊ณตํต์ธ ๋ฐฐ์ ์ค ๊ฐ์ฅ ์์ ์
- LCM์ 1๋ถํฐ ์์ํ์ฌ ์ ์ฐจ lcm++ ํ๋ฉด์ ๊ฐ๊ฐ์ ๋ ์๋ฅผ LCM์ผ๋ก ๋๋์์ ๋ ๋๋จธ์ง ๊ฐ์ด 0์ธ ์ง๋ฅผ ๋น๊ตํ๋ค.
- A*B/GCD
let getLCM = (num1, num2) =>{
let lcm = 1;
while(true){
if((lcm % num1 == 0) && (lcm % num2 == 0)){
break;
}
lcm++;
}
return lcm
}
๋ฉฑ์งํฉ
- ์งํฉ {1, 2, 3}์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ {}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3} ์ผ๋ก ๋์ดํ ์ ์๊ณ , ์ด ๋ถ๋ถ์งํฉ์ ์ด ๊ฐ์๋ 8๊ฐ์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ๋ชจ๋ ๋ถ๋ถ์งํฉ์ ํตํ์ด ๋ฉฑ์งํฉ์ด๋ผ๊ณ ํ๋ค.
- ์ด๋ค ์งํฉ์ด ์์ ๋, ์ด ์งํฉ์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ ๋ฉฑ์งํฉ์ด๋ผ๊ณ ํ๋ค.
๐ ์ถ๊ฐ๋ก ๊ณต๋ถํ ๋ด์ฉ
Study์๊ณผ ํจ๊ป ์งํ์ค์ธ ํ๋ก์ ํธ ๊ตฌํ
- ๋ก๊ทธ์ธ ํ ํ์์ ์ ๋ณด ๊ฐ์ ธ์ค๊ธฐ
๋๋ง์ ํฌํธํด๋ฆฌ์ค ์ฌ์ดํธ ๊ตฌํ ํด๋ณด๊ธฐ
- Figma๋ฅผ ์ฌ์ฉํ์ฌ ๋์์ธ ํด๋ณด๊ธฐ
๐ ์ค์ํ ๋ด์ฉ
- ์์ด
- ์กฐํฉ
- ์ต๋๊ณต์ฝ์
- ์ต์๊ณต๋ฐฐ์
- ๋ฉฑ์งํฉ
'Daily > Today I Learned' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
22.08.16_TIL (0) | 2022.08.16 |
---|---|
22.08.12_TIL (0) | 2022.08.12 |
22.08.10_TIL (0) | 2022.08.09 |
22.08.09_TIL (0) | 2022.08.09 |
22.08.08_TIL (0) | 2022.08.08 |