๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
3๏ธโƒฃ Swift/Problem Solving

[Swift Algorithm] ์ตœ์†Ÿ๊ฐ’ ๋งŒ๋“ค๊ธฐ Programmers(Lv.2)

by seolhee2750 2021. 6. 24.
๋ฌธ์ œ ์„ค๋ช…

๊ธธ์ด๊ฐ€ ๊ฐ™์€ ๋ฐฐ์—ด A, B ๋‘๊ฐœ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ฐ ๋ฐฐ์—ด์€ ์ž์—ฐ์ˆ˜๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์Šต๋‹ˆ๋‹ค.
๋ฐฐ์—ด A, B์—์„œ ๊ฐ๊ฐ ํ•œ ๊ฐœ์˜ ์ˆซ์ž๋ฅผ ๋ฝ‘์•„ ๋‘ ์ˆ˜๋ฅผ ๊ณฑํ•ฉ๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ๊ณผ์ •์„ ๋ฐฐ์—ด์˜ ๊ธธ์ด๋งŒํผ ๋ฐ˜๋ณตํ•˜๋ฉฐ, ๋‘ ์ˆ˜๋ฅผ ๊ณฑํ•œ ๊ฐ’์„ ๋ˆ„์ ํ•˜์—ฌ ๋”ํ•ฉ๋‹ˆ๋‹ค. ์ด๋•Œ ์ตœ์ข…์ ์œผ๋กœ ๋ˆ„์ ๋œ ๊ฐ’์ด ์ตœ์†Œ๊ฐ€ ๋˜๋„๋ก ๋งŒ๋“œ๋Š” ๊ฒƒ์ด ๋ชฉํ‘œ์ž…๋‹ˆ๋‹ค. (๋‹จ, ๊ฐ ๋ฐฐ์—ด์—์„œ k๋ฒˆ์งธ ์ˆซ์ž๋ฅผ ๋ฝ‘์•˜๋‹ค๋ฉด ๋‹ค์Œ์— k๋ฒˆ์งธ ์ˆซ์ž๋Š” ๋‹ค์‹œ ๋ฝ‘์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.)

์˜ˆ๋ฅผ ๋“ค์–ด A = [1, 4, 2] , B = [5, 4, 4] ๋ผ๋ฉด

  • A์—์„œ ์ฒซ๋ฒˆ์งธ ์ˆซ์ž์ธ 1, B์—์„œ ์ฒซ๋ฒˆ์งธ ์ˆซ์ž์ธ 5๋ฅผ ๋ฝ‘์•„ ๊ณฑํ•˜์—ฌ ๋”ํ•ฉ๋‹ˆ๋‹ค. (๋ˆ„์ ๋œ ๊ฐ’ : 0 + 5(1x5) = 5)
  • A์—์„œ ๋‘๋ฒˆ์งธ ์ˆซ์ž์ธ 4, B์—์„œ ์„ธ๋ฒˆ์งธ ์ˆซ์ž์ธ 4๋ฅผ ๋ฝ‘์•„ ๊ณฑํ•˜์—ฌ ๋”ํ•ฉ๋‹ˆ๋‹ค. (๋ˆ„์ ๋œ ๊ฐ’ : 5 + 16(4x4) = 21)
  • A์—์„œ ์„ธ๋ฒˆ์งธ ์ˆซ์ž์ธ 2, B์—์„œ ๋‘๋ฒˆ์งธ ์ˆซ์ž์ธ 4๋ฅผ ๋ฝ‘์•„ ๊ณฑํ•˜์—ฌ ๋”ํ•ฉ๋‹ˆ๋‹ค. (๋ˆ„์ ๋œ ๊ฐ’ : 21 + 8(2x4) = 29)

์ฆ‰, ์ด ๊ฒฝ์šฐ๊ฐ€ ์ตœ์†Œ๊ฐ€ ๋˜๋ฏ€๋กœ 29๋ฅผ return ํ•ฉ๋‹ˆ๋‹ค.

๋ฐฐ์—ด A, B๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ ์ตœ์ข…์ ์œผ๋กœ ๋ˆ„์ ๋œ ์ตœ์†Ÿ๊ฐ’์„ return ํ•˜๋Š” solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด ์ฃผ์„ธ์š”.

 

์ œํ•œ ์กฐ๊ฑด
  • ๋ฐฐ์—ด A, B์˜ ํฌ๊ธฐ : 1,000 ์ดํ•˜์˜ ์ž์—ฐ์ˆ˜
  • ๋ฐฐ์—ด A, B์˜ ์›์†Œ์˜ ํฌ๊ธฐ : 1,000 ์ดํ•˜์˜ ์ž์—ฐ์ˆ˜

 

์ž…์ถœ๋ ฅ ์˜ˆ
A B answer
[1, 4, 2] [5, 4, 4] 29
[1,2] [3,4] 10

 

๋‚ด ๋ฌธ์ œ ํ’€์ด
func solution(_ A:[Int], _ B:[Int]) -> Int {
    var result = 0
    let arrA = A.sorted(by: <) // ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌ
    let arrB = B.sorted(by: >) // ๋‚ด๋ฆผ์ฐจ์ˆœ ์ •๋ ฌ
    
    for i in 0..<A.count {
        result += arrA[i] * arrB[i]
    }

    return result
}
  • ๋จผ์ € ๋ฌธ์ œ๋ฅผ ๋ณด๊ณ , ํ•œ ๋ฐฐ์—ด์˜ ๊ฐ€์žฅ ์ž‘์€ ์ˆ˜์™€ ๊ฐ€์žฅ ํฐ ์ˆ˜๋ฅผ ๋งค์น˜ํ•ด์„œ ๊ณฑํ•ด ๋ˆ„์ ํ•˜๋ฉด ์ตœ์†Œ๊ฐ’์ด ๋˜๊ฒ ๋‹ค๊ณ  ์ƒ๊ฐํ–ˆ๋‹ค.
  • ๋”ฐ๋ผ์„œ A๋Š” ์˜ค๋ฆ„์ฐจ์ˆœ, B๋Š” ๋‚ด๋ฆผ์ฐจ์ˆœ์œผ๋กœ sortํ•ด์ฃผ์—ˆ๊ณ , ์ˆœ์„œ๋Œ€๋กœ ๊ณฑํ•ด์„œ ๋ˆ„์ ํ–ˆ๋‹ค.

 

๐Ÿ’ก ํ”ผ๋“œ๋ฐฑ
  • ์ข€ ๋” ์ฝ”๋“œ๋ฅผ ๊ฐ„๊ฒฐํžˆ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์„ ๊ฒƒ๋„ ๊ฐ™์€๋ฐ, ๋„์ €ํžˆ ๋– ์˜ค๋ฅด์ง€ ์•Š์•„ ์ด๋ ‡๊ฒŒ ๋งˆ๋ฌด๋ฆฌํ–ˆ๋‹ค.
  • ๊ณ ์ฐจํ•จ์ˆ˜ ๊ณต๋ถ€๊ฐ€ ๋” ํ•„์š”ํ• ๋“ฏ ํ•˜๋‹ค.

 


 

๐Ÿ– [ ์ถ”๊ฐ€ ] 1์ฃผ์ผ ํ›„ ๋‹ค์‹œ ํ’€์–ด๋ณด๊ธฐ

func solution(_ A:[Int], _ B:[Int]) -> Int {
    return zip(A.sorted(), B.sorted(by: >)).map(*).reduce(0, +)
}
  • ์ฒซ ๋ฒˆ์งธ๋กœ ํ’€์—ˆ์„ ๋•Œ์™€ ๋กœ์ง์€ ๊ฐ™๋‹ค. ํ•œ ๋ฐฐ์—ด์€ ์˜ค๋ฆ„์ฐจ์ˆœ, ํ•œ ๋ฐฐ์—ด์€ ๋‚ด๋ฆผ์ฐจ์ˆœ sort ํ•ด์ฃผ์—ˆ๋‹ค.
  • zip์œผ๋กœ ๋‘ ๋ฐฐ์—ด์„ ๋ฌถ์—ˆ๊ณ , map์„ ์‚ฌ์šฉํ•˜์—ฌ ๋‘ ๋ฐฐ์—ด์˜ ์ •๋ ฌ๋œ ๊ฐ’๋“ค์„ ์ˆœ์„œ๋Œ€๋กœ ๊ณฑํ•ด์ฃผ์—ˆ๋‹ค.
  • zip์„ ๊ณต๋ถ€ํ•˜๊ณ  ๋‚˜์„œ, zip์„ ์‚ฌ์šฉํ•˜๊ธฐ ๋”ฑ ์ข‹์€ ๋ฌธ์ œ์ธ ๊ฒƒ ๊ฐ™์•„ ์‚ฌ์šฉํ•ด๋ดค๋”๋‹ˆ ๋„ˆ๋ฌด ๊ฐ„๊ฒฐํ•˜๊ฒŒ ์ž˜ ์ž‘์„ฑ๋˜์—ˆ๋‹ค!

 


 

๋ฌธ์ œ

https://programmers.co.kr/learn/courses/30/lessons/12941

๋Œ“๊ธ€