MUKER_DEV with iOS

[swift] ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค - ๊ธฐ์‚ฌ๋‹จ์›์˜ ๋ฌด๊ธฐ ๋ณธ๋ฌธ

๐Ÿค– ์•Œ๊ณ ๋ฆฌ์ฆ˜/programmers

[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๋กœ ๋ฐฐ์—ด์„ ๋งŒ๋“œ๋Š” ๊ฑฐ๋ณด๋‹ค

๋ฉ”๋ชจ๋ฆฌ๋ฉด์—์„œ ํ›จ์”ฌ ์นœํ™˜๊ฒฝ์ ์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.