์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | ||||||
2 | 3 | 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | 13 | 14 | 15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 | 24 | 25 | 26 | 27 | 28 |
- dp
- Queue
- ํ๋ก๊ทธ๋๋จธ์ค
- dfs
- ๋ถํ ํ์
- Swift
- ios
- WebView
- BFS
- ๋ถํ ์ ๋ณต
- ์์
- ๋นํธ์ฐ์ฐ์
- ๋์ ํฉ
- ์ฝํ
- ์๊ณ ๋ฆฌ์ฆ
- ๋ฐฑํธ๋ํน
- ๋ฐฑ์ค
- SwiftUI
- ๋ธ๋ฃจํธํฌ์ค
- ๋ฌธ์์ด
- ๋ถํ ์ ๋ณต
- ์ด์งํ์
- ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ
- ๋ธ๋ฃจํธํฌ์ค ์๊ณ ๋ฆฌ์ฆ
- ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ
- WebApp
- ์ฝ๋ฉํ ์คํธ
- ์คํ
- Today
- Total
MUKER_DEV with iOS
[swift] ํ๋ก๊ทธ๋๋จธ์ค - ๊ธฐ์ฌ๋จ์์ ๋ฌด๊ธฐ ๋ณธ๋ฌธ
[swift] ํ๋ก๊ทธ๋๋จธ์ค - ๊ธฐ์ฌ๋จ์์ ๋ฌด๊ธฐ
MUKER 2023. 1. 25. 17:05ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๋ฌธ์ ํธ๋ ๋ฐ ์์ด ๋์์ด ๋๋๋ก ๋์ ํ์ด์ ๊ฐ์ ๋ ํ์ด๋ฅผ ์ฌ๋ฆฝ๋๋ค.
๋ํ ํ์ด ํ ๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ๋ณด๊ณ ์ฐธ๊ณ ํ ๋งํ ํ์ด๋ ์ฌ๋ฆฝ๋๋ค.
- ๋ฌธ์ ์ ๋ฐ๋ผ ๋์ ํ์ด๋ง ์์ ์ ์์ต๋๋ค.
- ํด๋น ํ์ด๋ค์ ํ์ด ์ค ํ๋์ผ ๋ฟ ์ต์ ์ ํ์ด๋ ์๋ ์ ์์ต๋๋ค.
๋ฌธ์ ์ค๋ช
๊ฐ๊ฐ์ ๊ธฐ์ฌ๋ ๊ธฐ์ฌ ๋ฒํธ(number)๋ฅผ ๊ฐ์ง๊ณ ์๊ณ
number์ ์ฝ์๋ ๊ธฐ์ฌ์ ๊ณต๊ฒฉ๋ ฅ์ ์๋ฏธํฉ๋๋ค.
๊ธฐ์ฌ์ ๊ณต๊ฒฉ๋ ฅ์ ๊ตฌํ๊ณ
๊ณต๊ฒฉ๋ ฅ์ด limit์ ๋๋๋ค๋ฉด power๋ก ๊ณต๊ฒฉ๋ ฅ์ด ๊ณ ์ ๋ฉ๋๋ค.
๊ธฐ์ฌ๋จ ์ ์ฒด์ ๊ณต๊ฒฉ๋ ฅ์ ํฉ์ ๊ตฌํ๋ฉด ๋๋ ๋ฌธ์ ์ ๋๋ค.
ํด๋น ๋ฌธ์ ์ ๊ตฌํ์ ์ฝ์ง๋ง
์๊ฐ์ ํ์ ํด๊ฒฐํด์ผ ํ๋ ํ์ด์ ๋๋ค.
์๊ฐ์ด๊ณผ ํ์ด(์ค๋ต ์ฝ๋)
import Foundation
func solution(_ number:Int, _ limit:Int, _ power:Int) -> Int {
var result = [Int]()
for i in 1...number {
result.append(0)
for j in 1...i {
if i % j == 0 {
result[i-1] += 1
}
}
}
for (index, value) in result.enumerated() {
if value > limit {
result[index] = power
}
}
return result.reduce(0,+)
}
๊ตฌํ์๋ ๋ฌธ์ ์์ด๋ณด์ด์ง๋ง
๋ง์ ๋ฌธ์ ์์ ์๊ฐ์ ํ์ ๊ฑธ๋ฆฝ๋๋ค.
์ค์ฒฉ for๋ฌธ ์์์
์ฝ์๋ฅผ ๊ตฌํ๋ ๋ฐ๋ณต์ด
O(n) ๊ฑธ๋ฆฌ๋ ๊ฒ ๋ฌธ์ ์ธ ๊ฑฐ ๊ฐ์ต๋๋ค.
๊ฐ์ ๋ ํ์ด
import Foundation
func solution(_ number:Int, _ limit:Int, _ power:Int) -> Int {
var result = [Int]()
for i in 1...number {
result.append(0)
for j in 1...Int(sqrt(Double(i))) {
if i % j == 0 {
if (j * j) == i {
result[i-1] += 1
} else {
result[i-1] += 2
}
}
if result[i-1] > limit {
result[i-1] = power
break
}
}
}
return result.reduce(0,+)
}
์ ๊ณฑ๊ทผ์ ํ์ฉํด์ ์ฝ์๋ฅผ ๊ตฌํ ์ ์๋ค๊ณ ํฉ๋๋ค.
๋ค์ ์ํ์ ์ด์ง๋ ์์ง๋ง
์ ๊ณฑ๊ทผ๊ณผ ์ฝ์์ ์๊ด๊ด๊ณ๋ฅผ ์์๋ด ์๋ค.
100์ ์ ๊ณฑ๊ทผ์ 10์ ๋๋ค.
10์ ์ฝ์ 1,2,4,5,10์ด ๋์ค๊ณ
100์ ์ฝ์ 1,2,4,5,10,20,25,50,100์ด ๋์ต๋๋ค.
๋ณด๊ฒ ๋๋ฉด 100์ ์ฝ์ ๊ฐ์๊ฐ
์ ๊ณฑ๊ทผ(10)์ ๊ธฐ์ค์ผ๋ก
10์ ์ฝ์์ ๊ฐ์๋งํผ ๋์นญ์ ์ด๋ฃจ๊ณ ์์ต๋๋ค.
1,2,4,5 10 20,25,50,100
์ฆ ์ ๊ณฑ๊ทผ์ ์ฝ์๋ง ๊ตฌํด๋
์ฝ๊ฒ ์ฝ์์ ๊ฐ์๋ฅผ ์ ์ถํ๊ธฐ ์ฝ์ต๋๋ค.
100๋ฒ ๋ฐ๋ณตํ ๊ฑธ 10/1๋ก ์ค์ฌ์ค ์ ์์ต๋๋ค.
์ฐธ๊ณ ํ ๋งํ ํ์ด
import Foundation
func solution(_ number:Int, _ limit:Int, _ power:Int) -> Int {
var attack = [Int](repeating: 0, count: number+1)
for i in 1...number {
var c = i
while c <= number {
attack[c] += 1
c += i
}
}
attack = attack.map { $0 > limit ? power : $0 }
return attack.reduce(0, +)
}
์ฝ์๋ฅผ ๊ตฌํ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ์์ด ๊ฐ์ ธ์์ต๋๋ค.
์ด๋ ๊ฒ [Int](repeating: , count: )๋ก ๋ฐฐ์ด์ ๋ง๋ค์ด ์ฃผ๋ ๊ฒ
๋์ฒ๋ผ [Int]()์ append๋ก ๋ฐฐ์ด์ ๋ง๋๋ ๊ฑฐ๋ณด๋ค
๋ฉ๋ชจ๋ฆฌ๋ฉด์์ ํจ์ฌ ์นํ๊ฒฝ์ ์ด๋ผ๊ณ ํฉ๋๋ค.
'๐ค ์๊ณ ๋ฆฌ์ฆ > programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[swift] ํ๋ก๊ทธ๋๋จธ์ค - ๋ก๋์ ์ต๊ณ ์์์ ์ต์ ์์ (0) | 2023.01.27 |
---|---|
[swift] ํ๋ก๊ทธ๋๋จธ์ค - ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฐ์ ๊ธ์ (0) | 2023.01.26 |
[swift] ํ๋ก๊ทธ๋๋จธ์ค - ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ฒ์ (0) | 2023.01.20 |
[swift] ํ๋ก๊ทธ๋๋จธ์ค - ํคํจ๋ ๋๋ฅด๊ธฐ (0) | 2023.01.19 |
[swift] ํ๋ก๊ทธ๋๋จธ์ค - [1์ฐจ] ๋คํธ ๊ฒ์ (0) | 2023.01.18 |