๐ ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
-Swift-CodingTest/ํ๋ก๊ทธ๋๋จธ์ค/2/12953.โ N๊ฐ์โ ์ต์๊ณต๋ฐฐ์ at main · BaeJihae/-Swift-CodingTest
Swift๋ก ํผ ์ฝ๋ฉ ํ ์คํธ ๋ฌธ์ ๋ค์ ์ ๋ฆฌํ๊ณ ๊ณต๋ถํ๋ ๊ณต๊ฐ์ ๋๋ค. Contribute to BaeJihae/-Swift-CodingTest development by creating an account on GitHub.
github.com
๋ฌธ์ ์ค๋ช
๋ ์์ ์ต์๊ณต๋ฐฐ์(Least Common Multiple)๋ ์ ๋ ฅ๋ ๋ ์์ ๋ฐฐ์ ์ค ๊ณตํต์ด ๋๋ ๊ฐ์ฅ ์์ ์ซ์๋ฅผ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด 2์ 7์ ์ต์๊ณต๋ฐฐ์๋ 14๊ฐ ๋ฉ๋๋ค. ์ ์๋ฅผ ํ์ฅํด์, n๊ฐ์ ์์ ์ต์๊ณต๋ฐฐ์๋ n ๊ฐ์ ์๋ค์ ๋ฐฐ์ ์ค ๊ณตํต์ด ๋๋ ๊ฐ์ฅ ์์ ์ซ์๊ฐ ๋ฉ๋๋ค. n๊ฐ์ ์ซ์๋ฅผ ๋ด์ ๋ฐฐ์ด arr์ด ์ ๋ ฅ๋์์ ๋ ์ด ์๋ค์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด ์ฃผ์ธ์.
์ ํ ์ฌํญ
- arr์ ๊ธธ์ด 1์ด์, 15์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค.
- arr์ ์์๋ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
arr | result |
[2,6,8,14] | 168 |
[1,2,3] | 6 |
๋ฌธ์ ํ์ด
๋์ ํ์ด
import Foundation
func solution(_ arr:[Int]) -> Int {
// ์์ ๋ฐฐ์ด
let a = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
// ์ต๋๊ณต์ฝ์์ ์์ธ์๋ถํด [ ์์ : ์์์ ๊ฐ์ ]
var maxDic = [Int:Int]()
for num in arr {
var n = num
for i in a {
var k = 0
if n == 1 { // 1์ธ ๊ฒฝ์ฐ ๋ฐ๋ณต๋ฌธ ๋น ์ ธ ๋๊ฐ๊ธฐ
continue
}
while n % i == 0 { // i์ด n์ ์ฝ์์ผ ๋
k += 1 // ์์ ๋์จ ๊ฐ์ ๊ฐฏ์๋ฅผ ์ฒดํฌํ๊ธฐ ์ํด
n = n / i
if ( maxDic[i] ?? 0 ) < k { // ์์ ๋์จ ์์์ ๊ฐ์๋ณด๋ค ๋ง์ ๊ฒฝ์ฐ ์
๋ฐ์ดํธ
maxDic[i] = ( maxDic[i] ?? 0 ) + 1
}
}
}
}
// ์์ธ์๋ถํด๋ ์ต์๊ณต๋ฐฐ์์ ๊ฐ ๊ณ์ฐ
return maxDic.reduce(1){ $0 * Int(pow(Float($1.key), Float($1.value)))}
}
์ต๋๊ณต์ฝ์์ ์์๋ฅผ ์ฐพ์์ ํ์๋ค.
๋ฐฐ์ด์ ๊ธธ์ด์ ์ต๋๊ฐ์๊ฐ 15์ด๊ณ , arr์ ์์๊ฐ 100์ดํ์ด๋ฏ๋ก for๋ฌธ์ด๋ ๋ฐ๋ณต๋ฌธ์ ๋๋ ค๋ ์๊ฐ์ด ์ถฉ๋ถํ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ค.
100์ดํ์ ์์ ๋ฐฐ์ด์ ๋๋๊ณ , ํด๋น ๊ฐ์ ์์๋ฅผ ์ฐพ์ผ๋ฉฐ ๋์ ๋๋ฆฌ์ ์ ์ฅํ๋ค.
์ด ๋, ์ ์ซ์์์ ์ด๋ฏธ ์์๋ก ์ ์ฅ์ด ๋์๋ค๋ฉด, ๊ฐ์ ์ ๋ฐ์ดํธ ํ์ง ๋ง์์ผ ํ๋ค.
์ด ๋ถ๋ถ์์ ๋ง์ด ๊ณ ๋ฏผํ์๋ค. ๊ทธ๋์ k๊ฐ์ ๋๊ธฐ๋ก ํ๋ค.
๋ฐ๋ณต๋ฌธ์ ๋๋๋ง๋ค 1์ด ์ฌ๋ผ๊ฐ๋ค๋ ๊ฒ์ ํด๋น ์์๊ฐ์ด ๋ฐ๋ณต๋๋ค๋ ๋ป์ด๋ฏ๋ก k๊ฐ๋ณด๋ค ์์์ ๊ฐ์๊ฐ ํฌ๊ฑฐ๋ ๊ฐ๋ค๋ฉด ๊ฐ์ ์ ๋ฐ์ดํธํ์ง ์๋๋ก ๋ก์ง์ ๊ตฌํํ๋ค.
4๋ฒ์์ ์ผ์ด์ค ์ค๋ฅ๊ฐ ๋ฌ๋๋ฐ, ๊ทธ ๋ถ๋ถ์ ๋ด๊ฐ ์๊ฐ์ ์ค์ด๊ธฐ ์ํด num๊ฐ a๋ฐฐ์ด์ ํฌํจ์ด ๋์ด์๋ค๋ฉด, ํด๋น ๊ฐ์ ์์ ๊ทธ ์์ฒด์ด๋ฏ๋ก ๋์ ๋๋ฆฌ์ ์ ๋ฐ์ดํธ๋ฅผ ํ๊ณ ๋ค์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋์ด๊ฐ๋๋ก ๊ตฌํ์ ํ์๋๋ฐ, ์ด ๋ถ๋ถ์์ ๋์ ๋๋ฆฌ์ ์ ๋ฐ์ดํธ๋ฅผ ํ ๋๋ ์ด๋ฏธ ๋์ ๋๋ฆฌ์ ์๋ ๊ฐ์ธ์ง ํ์ธํ ํ์ ๊ฐฏ์๋ฅผ ๊ณ ๋ คํด์ ๋์ ์ ํด์ผํ๋ค. ๋ ๋นํจ์จ์ ์ธ ์ฝ๋๋ผ ๊ทธ ๋ถ๋ถ์ ๋นผ๋ ์ ์์ ์ผ๋ก ์๋ํ์๋ค.
๋ค๋ฅธ ์ฌ๋ ํ์ด
func gcd(_ a: Int, _ b: Int) -> Int {
let r = a % b
if r != 0 {
return gcd(b, r)
} else {
return b
}
}
func lcm(_ m: Int, _ n: Int) -> Int {
return m / gcd(m, n) * n
}
func solution(_ arr:[Int]) -> Int {
return arr.reduce(1) { lcm($0, $1) }
}
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ผ๋ก ํผ ๋ฌธ์ ์ด๋ค. ์ด ํ์ด๋ฅผ ๊ผญ ์ตํ๋์ด์ผ ๊ฒ ๋ค.