๋ฌธ์ ํ์ด
import Foundation
func solution(_ n:Int) -> Int {
var inVal = String(n, radix: 3)
var ansArr = inVal.map{ Int(String($0))! }
var ansVal: Int = 0
for i in 0..<ansArr.count {
ansVal += ansArr[i] * Int(pow(3.0, Double(i)))
}
return ansVal
}
๋งจ ์ฒ์ ๋ฌธ์ ๋ฅผ ๋ดค์ ๋, ํด๋น ํ์ด์๋ ๋ค๋ฅด๊ฒ ์ ๊ทผํ์๋ค.
์ ๋ ฅ๊ฐ(10์ง๋ฒ)์ 3์ง๋ฒ ์๋ก ๋ณํํ์ฌ ๊ฐ์ ๋ค์ง๊ณ , ์ดํ ๋ค์ 10์ง๋ฒ์ผ๋ก ๋ณํํ์ฌ ์ต์ข ๊ฐ์ ๋ฐํํ๋ ๋ฐฉ๋ฒ์ ๊ตฌ์ํ์๋ค.
var inVal = String(n, radix: 3)
var ansArr = inVal.map{ Int(String($0))! }
ansArr.reverse()
var ansStr = Int(ansArr.map(String.init).joined())!
์ ์ฝ๋์์ ๋ณผ ์ ์๋ฏ์ด 3์ง๋ฒ ์๋ก ๋ณํ๋ ๊ฐ์ ๋ค์ง์ด 10์ง๋ฒ์ผ๋ก ๋ณํํ๊ธฐ ์ ๋จ๊ณ๊น์ง ์จ ๊ฒ์ ๋ณผ ์ ์๋ค.
ํ์ง๋ง ํด๋น ํํธ์์ ์ง์ ์ด ์์ด ๋งจ ์์ ํ์ด ๋ฐฉ๋ฒ์ผ๋ก ์์ ํ์๋ค.
์
๋ ฅ๊ฐ์ map
ํจ์๋ฅผ ์ฌ์ฉํ์ฌ [Int]
ํ์
์ผ๋ก ๋ณํํด์ฃผ๊ณ , ์ฒซ๋ฒ์งธ ์ธ๋ฑ์ค ๊ฐ๋ถํฐ 3์ ์ ๊ณฑ๊ฐ์ ๊ณฑํ์ฌ ์ฃผ์๋ค.
๊ทธ๋ฌ๋ฉด ๊ตณ์ด ์ ๋ ฅ๊ฐ์ ๋ค์ง์ ํ์๋ ์๊ธฐ ๋๋ฌธ์ด๋ค!
๋ฌธ์ ํ์ด
import Foundation
let n = readLine()!.components(separatedBy: [" "]).map { Int($0)! }
let (a, b) = (n[0], n[1])
var ans: String = ""
for i in 0..<a {
ans.append("*")
}
for j in 0..<b {
print(ans)
}
์์ ํ์ด๋ณด๋ค ๊ด์ฐฎ์ ๋ฐฉ๋ฒ์ ์ฐพ์๋ดค์ง๋ง, ์์ฝ๊ฒ๋ ์์ํ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํ์๋ค...
for
๋ฌธ์ 2๋ฒ ํ์ฉํ์ฌ, * ๋ฌธ์๋ฅผ ans
์ ์ถ๊ฐํ์ฌ ๊ฐ๋ก ๊ธธ์ด๋ฅผ ์ ์ฅํด์ฃผ๊ณ ์ธ๋ก ๊ธธ์ด์ ๋ง์ถฐ ์ฌ๋ฌ๋ฒ ์ถ๋ ฅํด์ฃผ์๋ค.
๋ค์์ ๋์ฑ ๊น๋ํ ํ์ด ๋ฐฉ๋ฒ์ ์ฐพ์๋ด์ผ๊ฒ ๋ค.
๋ฌธ์ ํ์ด
func solution(_ s:String) -> Bool {
var ansCounter: Int = 0
var mapArr = s.map{ Int(String($0)) }
!mapArr.contains(nil) ? (ansCounter += 1) : (ansCounter += 0)
mapArr.count == 4 || mapArr.count == 6 ? (ansCounter += 1) : (ansCounter += 0)
return ansCounter == 2 ? true : false
}
์ค๋ ํผ ๋ฌธ์ ์ค์์ ํด๋น ๋ฌธ์ ๋ฅผ ๊ฐ์ฅ ์ ํผ ๊ฒ ๊ฐ๋ค!
์ฐ์ ์
๋ ฅ๊ฐ์ map
ํจ์๋ฅผ ํ์ฉํ์ฌ, [Int]
์ผ๋ก ๋ณํํ์๋ค. ์ด๋, ์ซ์๊ฐ ์๋ ๊ธ์๊ฐ ์
๋ ฅ๋๋ฉด nil
๊ฐ์ด ์ ์ฅ๋๋ค.
๋ฐ๋ผ์ ์ด๋ฌํ ์ ์ ํ์ฉํ์ฌ ๋ฐฐ์ด ๋ด์ nil
์ด ์กด์ฌํ๋ฉด ์นด์ด๋์ 1์ด ์ถ๊ฐ๋๋๋ก ํ์๊ณ , ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 4๋ 6์ผ ๋ ์นด์ด๋๊ฐ ํ๋ฒ ๋ ๋์ํ๋๋ก ๋ง๋ค์๋ค.
๋ง์ง๋ง์ผ๋ก ์นด์ดํฐ๊ฐ 2์ผ ๋, ์ผํญ์ฐ์ฐ์๋ฅผ ํ์ฉํ์ฌ true๊ฐ ๋ฐํ๋๋๋ก ๋ง๋ค์๋ค.
ํด๋น ๋ฌธ์ ๋ฅผ ์ ์ถํ๊ณ ์ง๊ธ๊น์ง ๋ฐ์๋ณธ์ ์๋ ๋ฌด๋ ค 12์ ์ ๋ฐ์๋ค!!!