๋ฌธ์ ํ์ด
func solution(_ n:Int64) -> Int64 {
var val = String(Int64(n)).map{Int64(String($0))!}
val.sort(by: >)
var ans = val.map(String.init).joined()
return Int64(ans)!
}
solution ํจ์ ์ฒซ ์ค์์ val์ ์ดํด๋ณด๋ฉด map ํจ์๋ฅผ ์ฌ์ฉํ ๊ฒ์ ๋ณผ ์ ์๋ค. Int64 ํํ๋ก ์ ๋ ฅ๋๋ ์ ๋ ฅ๊ฐ n์ ๊ฐ ์๋ฆฟ์๋ง๋ค ๋ถ๋ฆฌํ์ฌ String ํํ๋ก ์ ๋ฆฌํ์๋ค. ์ดํ map ํจ์๊ฐ ๋ฐฐ์ด๋ก ๊ฒฐ๊ณผ๊ฐ์ ๋ฐํํ๋ ์ ์ ํ์ฉํ์ฌ sort ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐฐ์ด์ ์ ๋ ฌํด์ฃผ์๋ค.
๋ง์ง๋ง์ผ๋ก ๋ฐฐ์ด์ ๊ฐ ์๋ฆฟ์๋ง๋ค ๋ถ๋ฆฌ๋์ด ์๋ val ๊ฐ์ String ํ์ ์ผ๋ก ์ด๊ธฐํํด์ฃผ๊ณ joined()๋ฅผ ํ์ฉํ์ฌ ๋ชจ๋ ๊ฐ์ ๋ถ์ฌ์ฃผ์๋ค.
์ง์ง!! ์ง์ง! ๋ง์ง๋ง์ผ๋ก ๊ฒฐ๊ณผ๊ฐ ans๋ฅผ Int64๋ก ๋ณํํ์ฌ solution์ ๊ฒฐ๊ณผ๊ฐ์ผ๋ก ๋ฐํํ์๋ค!
๋ฌธ์ ํ์ด
import Foundation
func solution(_ n:Int64) -> Int64 {
var ans: Int64 = 0
var val: Int64 = Int64(sqrt(Double(n)))
ans = (val*val == n) ? (val+1)*(val+1) : -1
return ans
}
ํด๋น ๋ฌธ์ ๋ฅผ ๋์ฑ ํธํ๊ฒ ํ๊ธฐ ์ํด ์ ๊ณฑ์ ๋ํ sqrt ํจ์๋ฅผ ์ฌ์ฉํ์๋ค. ์ด๋, sqrt ํจ์๋ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ Double์ ๊ธฐ์ค์ผ๋ก ํ๊ธฐ ๋๋ฌธ์ ์์์ ๋ณผ ์ ์๋ฏ์ด ์ฝ๋๋ฅผ ๊ตฌ์ฑํ์๋ค.
์ดํ, ์ผํญ์ฐ์ฐ์๋ฅผ ํ์ฉํ์ฌ ๋ฌธ์ ์กฐ๊ฑด์ ๋ง๋ ์ฝ๋๋ฅผ ์์ฑํ์๋ค.
๋ฌธ์ ํ์ด
func solution(_ x:Int) -> Bool {
var val1 = String(x).map{Int(String($0))!}
var val2: Int = 0
for i in 0..<val1.count {
val2 += val1[i]
}
return x % val2 == 0 ? true : false
}
ํด๋น ๋ฌธ์ ๋ ๋งจ ์ฒ์ ๋ฌธ์ ์ ๋น์ทํ๊ฒ ์ ๊ทผํ์๋ค. val1 ๊ฐ์ ๊ฐ ์๋ฆฟ์๋ง๋ค ์ ์ฅ๋ ๋ฐฐ์ด๋ก ๋ง๋ค์ด val2์ ๊ฐ ์๋ฆฟ์ ๊ฐ์ ๋ํด์ฃผ์๋ค.
๊ทธ๋ฆฌ๊ณ return์์ ์ผํญ์ฐ์ฐ์๋ฅผ ํ์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์๋ค.
์ง๊ธ๊น์ง ์ฌ์ ์บ ํ ๊ธฐ๊ฐ์ด์๊ณ , ์ ๋ฒ์ฃผ๋ ์จ๋ณด๋ฉ ๊ธฐ๊ฐ์ผ๋ก ์ค์ง์ ์ธ ํ๋ก์ ํธ๋ฅผ ์ํํ์ง ์์๋ค.
์๋ง ํํ๋ก์ ํธ๋ฅผ ํ๋ค๊ณ ํด๋, ๊ฐ๋ฐ ์ง์์ด ์์ด ์งํ์ ์ด๋ ค์์ ๊ฒช์์ ๊ฒ์ด๋ค... ๐ฅฒ
ํ์ง๋ง ์ค๋๋ถํฐ ๋ณธ์บ ํ๊ฐ ์์๋์ด ๋์ฑ ๋์๋๋ ๊ธฐ๋๊ฐ ๋๋ค!! ๐