์๋ ํ์ธ์ ์ ์ธ์ ๋๋ค!!
์ค๋์ ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ ์๊ฒ๋ ์ต๋๊ณต์ฝ์, ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด ๊ธฐ๋กํด๋ณด๋ ค๊ณ ํฉ๋๋ค!
ํ๋ก๊ทธ๋๋จธ์ค์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์ ๋ฌธ์ ๋ ๋ ๋ฒจ1์ ๊ฐ๋จํ ๋ฌธ์ ์ด์ง๋ง
์ต๋๊ณต์ฝ์, ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ๊ณต์(?)๊ณผ ๊ฐ์ ๊ฐ๋ ์ ์๊ณ ์์ง ์๋ค๋ฉด ์ฝ๊ฒ ํ ์ ์๋ ๋ฌธ์ ์ด๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ ๋ฌธ์ ๋ค์์์ ์์ฉ์ ๋๋นํด ์ ๋ฆฌํ๊ณ ๋์ด๊ฐ๋ ค๊ณ ํฉ๋๋ค!!
๋ฌธ์ ๋งํฌ
๋ฌธ์ ์ค๋ช
๋ ์๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ ์์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด ๋ณด์ธ์. ๋ฐฐ์ด์ ๋งจ ์์ ์ต๋๊ณต์ฝ์, ๊ทธ๋ค์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๋ฃ์ด ๋ฐํํ๋ฉด ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ ์ 3, 12์ ์ต๋๊ณต์ฝ์๋ 3, ์ต์๊ณต๋ฐฐ์๋ 12์ด๋ฏ๋ก solution(3, 12)๋ [3, 12]๋ฅผ ๋ฐํํด์ผ ํฉ๋๋ค.
์ ํ ์ฌํญ
- ๋ ์๋ 1์ด์ 1000000์ดํ์ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
n | m | return |
3 | 12 | [3, 12] |
2 | 5 | [1, 10] |
์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
์์ ์ค๋ช
๊ณผ ๊ฐ์ต๋๋ค.
์
์ถ๋ ฅ ์ #2
์์ฐ์ 2์ 5์ ์ต๋๊ณต์ฝ์๋ 1, ์ต์๊ณต๋ฐฐ์๋ 10์ด๋ฏ๋ก [1, 10]์ ๋ฆฌํดํด์ผ ํฉ๋๋ค.
๋ฌธ์ ํ์ด
์ฝ์, ๋ฐฐ์ ๊ตฌํ๊ธฐ๋ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๋ฉด ์ฝ๋๋ก๋ ๊ฐ๋จํ๊ฒ ๊ตฌํ์ด ๋๊ธฐ ๋๋ฌธ์ ์ด ๋ฌธ์ ๋ ์ฝ๊ฒ ํ ์ ์์ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋๋ฐ,
๋ง์ ๋ ์์ ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ์ฝ๋๋ฅผ ์์ฑํ๋ ค๊ณ ํ๋ ์ด๋ผ๋ผ.. ์ฝ๋๊ฐ ์์ฒญ ๋ณต์กํด์ง๊ณ ..
๋ญ๊ฐ ๋ฌธ์ ์ ์๋๋ ์ด๊ฒ ์๋ ๊ฒ ๊ฐ๊ณ ..ํด์ ํ์ด๋ฅผ ์ฐพ์๋ณด๊ฒ ๋์๋ค.
๋จผ์ , ์ต๋๊ณต์ฝ์๋ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ด์ฉํด ๊ตฌํ ์ ์์ต๋๋ค.
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ๊ฐ๋จํ ์ ๋ฆฌํด๋ณด์๋ฉด, ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
2๊ฐ์ ์์ฐ์(๋๋ ์ ์) a, b์ ๋ํด์ a๋ฅผ b๋ก ๋๋ ๋๋จธ์ง๋ฅผ r์ด๋ผ ํ๋ฉด (๋จ, a>b),
a์ b์ ์ต๋๊ณต์ฝ์๋ b์ r์ ์ต๋๊ณต์ฝ์์ ๊ฐ๋ค.
์ด ์ฑ์ง์ ๋ฐ๋ผ, b๋ฅผ r๋ก ๋๋ ๋๋จธ์ง r'์ ๊ตฌํ๊ณ , ๋ค์ r์ r'๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ ๊ณผ์ ์ ๋ฐ๋ณตํ์ฌ
๋๋จธ์ง๊ฐ 0์ด ๋์์ ๋ ๋๋๋ ์๊ฐ a์ b์ ์ต๋๊ณต์ฝ์์ ๋๋ค!
์ด๋ฅผ ์ฝ๋๋ก ๊ตฌํํ๋ฉด, a๋ฅผ b๋ก ๋๋ ๋๋จธ์ง ๊ฐ์ด 0์ผ ๋๊น์ง ๋ฐ๋ณต๋๋ ์ฌ๊ทํจ์ ํํ๋ก ๊ตฌํํ ์ ์์ต๋๋ค.
/// ์ต๋๊ณต์ฝ์
func gcd(_ a: Int, _ b: Int) -> Int {
if b == 0 {
return a
} else {
return gcd(b, a % b)
}
}
์ต์๊ณต๋ฐฐ์๋ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ค๋ฉด ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์์ ๊ด๊ณ๋ฅผ ์ด์ฉํด ์ฝ๊ฒ ๊ตฌํ ์ ์์ต๋๋ค!
์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์์ ๊ด๊ณ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๋ ์์ฐ์ A, B์ ์ต๋๊ณต์ฝ์๊ฐ G์ด๊ณ , ์ต์๊ณต๋ฐฐ์๊ฐ L์ผ ๋,
A = a x G, B = b x G (a, b๋ ์๋ก์) ๋ผ ํ๋ฉด ๋ค์์ด ์ฑ๋ฆฝํ๋ค.
1) L = a x b x G
2) A x B = L x G
์ฆ, ๋ ์๋ฅผ ๊ณฑํ ๊ฐ์ ๋ ์์ ์ต๋๊ณต์ฝ์ x ์ต์๊ณต๋ฐฐ์ ์ ๊ฐ์ต๋๋ค!
a*b = ์ต๋๊ณต์ฝ์ * ์ต์๊ณต๋ฐฐ์๋ฅผ ํ์ฉํด ์ฝ๋๋ก ๊ตฌํํด๋ณด๋ฉด ์๋์ ๊ฐ์ด ๊ตฌํํ ์ ์์ต๋๋ค.
/// ์ต์๊ณต๋ฐฐ์
func lcm(_ a: Int, _ b: Int) -> Int {
return a * b / gcd(a, b)
}
์ ์ฒด ์ฝ๋
/// ์ต๋๊ณต์ฝ์
func gcd(_ a: Int, _ b: Int) -> Int {
if b == 0 {
return a
} else {
return gcd(b, a % b)
}
}
/// ์ต์๊ณต๋ฐฐ์
func lcm(_ a: Int, _ b: Int) -> Int {
return a * b / gcd(a, b)
}
func solution(_ n:Int, _ m:Int) -> [Int] {
return [gcd(n, m), lcm(n, m)]
}
[์ฐธ๊ณ ์๋ฃ]
https://ko.wikipedia.org/wiki/์ ํด๋ฆฌ๋_ํธ์ ๋ฒ
https://hongjeongseob82.medium.com/ios-swift-gcd-lgm-์ต๋๊ณต์ฝ์-์ต์๊ณต๋ฐฐ์-49d57a36fda3
https://velog.io/@2dubu/Swift-์๊ณ ๋ฆฌ์ฆ-์ต๋๊ณต์ฝ์์-์ต์๊ณต๋ฐฐ์
'๐ฅ CS > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm/Swift] ํ๋ก๊ทธ๋๋จธ์ค(Lv.2) - ๋ฌด์ธ๋ ์ฌํ (1) | 2023.01.29 |
---|---|
[Algorithm/Swift] ๋์ ๊ณํ๋ฒ(Dynamic Programming) (2) | 2023.01.11 |
[Algorithm/Swift] ํ๋ก๊ทธ๋๋จธ์ค(Lv.1) - [1์ฐจ] ๋คํธ๊ฒ์ (0) | 2022.12.17 |
[Algorithm/Swift] BFS(๋๋น ์ฐ์ ํ์) Swift๋ก ๊ตฌํํด๋ณด๊ธฐ (0) | 2022.12.02 |
[Algorithm/Swift] DFS(๊น์ด ์ฐ์ ํ์) Swift๋ก ๊ตฌํํด๋ณด๊ธฐ (0) | 2022.10.04 |