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

[Swift Algorithm] ๋กœ๋˜์˜ ์ตœ๊ณ  ์ˆœ์œ„์™€ ์ตœ์ € ์ˆœ์œ„ Programmers(Lv.1)

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

๋กœ๋˜ 6/45(์ดํ•˜ '๋กœ๋˜'๋กœ ํ‘œ๊ธฐ)๋Š” 1๋ถ€ํ„ฐ 45๊นŒ์ง€์˜ ์ˆซ์ž ์ค‘ 6๊ฐœ๋ฅผ ์ฐ์–ด์„œ ๋งžํžˆ๋Š” ๋Œ€ํ‘œ์ ์ธ ๋ณต๊ถŒ์ž…๋‹ˆ๋‹ค. ์•„๋ž˜๋Š” ๋กœ๋˜์˜ ์ˆœ์œ„๋ฅผ ์ •ํ•˜๋Š” ๋ฐฉ์‹์ž…๋‹ˆ๋‹ค. 

์ˆœ์œ„ ๋‹น์ฒจ ๋‚ด์šฉ
1 6๊ฐœ ๋ฒˆํ˜ธ๊ฐ€ ๋ชจ๋‘ ์ผ์น˜
2 5๊ฐœ ๋ฒˆํ˜ธ๊ฐ€ ์ผ์น˜
3 4๊ฐœ ๋ฒˆํ˜ธ๊ฐ€ ์ผ์น˜
4 3๊ฐœ ๋ฒˆํ˜ธ๊ฐ€ ์ผ์น˜
5 2๊ฐœ ๋ฒˆํ˜ธ๊ฐ€ ์ผ์น˜
6(๋‚™์ฒจ) ๊ทธ ์™ธ

๋กœ๋˜๋ฅผ ๊ตฌ๋งคํ•œ ๋ฏผ์šฐ๋Š” ๋‹น์ฒจ ๋ฒˆํ˜ธ ๋ฐœํ‘œ์ผ์„ ํ•™์ˆ˜๊ณ ๋Œ€ํ•˜๊ณ  ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ, ๋ฏผ์šฐ์˜ ๋™์ƒ์ด ๋กœ๋˜์— ๋‚™์„œ๋ฅผ ํ•˜์—ฌ, ์ผ๋ถ€ ๋ฒˆํ˜ธ๋ฅผ ์•Œ์•„๋ณผ ์ˆ˜ ์—†๊ฒŒ ๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ๋‹น์ฒจ ๋ฒˆํ˜ธ ๋ฐœํ‘œ ํ›„, ๋ฏผ์šฐ๋Š” ์ž์‹ ์ด ๊ตฌ๋งคํ–ˆ๋˜ ๋กœ๋˜๋กœ ๋‹น์ฒจ์ด ๊ฐ€๋Šฅํ–ˆ๋˜ ์ตœ๊ณ  ์ˆœ์œ„์™€ ์ตœ์ € ์ˆœ์œ„๋ฅผ ์•Œ์•„๋ณด๊ณ  ์‹ถ์–ด ์กŒ์Šต๋‹ˆ๋‹ค.
์•Œ์•„๋ณผ ์ˆ˜ ์—†๋Š” ๋ฒˆํ˜ธ๋ฅผ 0์œผ๋กœ ํ‘œ๊ธฐํ•˜๊ธฐ๋กœ ํ•˜๊ณ , ๋ฏผ์šฐ๊ฐ€ ๊ตฌ๋งคํ•œ ๋กœ๋˜ ๋ฒˆํ˜ธ 6๊ฐœ๊ฐ€ 44, 1, 0, 0, 31 25๋ผ๊ณ  ๊ฐ€์ •ํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ๋‹น์ฒจ ๋ฒˆํ˜ธ 6๊ฐœ๊ฐ€ 31, 10, 45, 1, 6, 19๋ผ๋ฉด, ๋‹น์ฒจ ๊ฐ€๋Šฅํ•œ ์ตœ๊ณ  ์ˆœ์œ„์™€ ์ตœ์ € ์ˆœ์œ„์˜ ํ•œ ์˜ˆ๋Š” ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๋‹น์ฒจ ๋ฒˆํ˜ธ 31 10 45 1 6 19 ๊ฒฐ๊ณผ
์ตœ๊ณ  ์ˆœ์œ„ ๋ฒˆํ˜ธ 31 0→10 44 1 0→6 25 4๊ฐœ ๋ฒˆํ˜ธ ์ผ์น˜, 3๋“ฑ
์ตœ์ € ์ˆœ์œ„ ๋ฒˆํ˜ธ 31 0→11 44 1 0→7 25 2๊ฐœ ๋ฒˆํ˜ธ ์ผ์น˜, 5๋“ฑ
  • ์ˆœ์„œ์™€ ์ƒ๊ด€์—†์ด, ๊ตฌ๋งคํ•œ ๋กœ๋˜์— ๋‹น์ฒจ ๋ฒˆํ˜ธ์™€ ์ผ์น˜ํ•˜๋Š” ๋ฒˆํ˜ธ๊ฐ€ ์žˆ์œผ๋ฉด ๋งžํžŒ ๊ฑธ๋กœ ์ธ์ •๋ฉ๋‹ˆ๋‹ค.
  • ์•Œ์•„๋ณผ ์ˆ˜ ์—†๋Š” ๋‘ ๊ฐœ์˜ ๋ฒˆํ˜ธ๋ฅผ ๊ฐ๊ฐ 10, 6์ด๋ผ๊ณ  ๊ฐ€์ •ํ•˜๋ฉด 3๋“ฑ์— ๋‹น์ฒจ๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
    • 3๋“ฑ์„ ๋งŒ๋“œ๋Š” ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•๋“ค๋„ ์กด์žฌํ•ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ, 2๋“ฑ ์ด์ƒ์œผ๋กœ ๋งŒ๋“œ๋Š” ๊ฒƒ์€ ๋ถˆ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.
  • ์•Œ์•„๋ณผ ์ˆ˜ ์—†๋Š” ๋‘ ๊ฐœ์˜ ๋ฒˆํ˜ธ๋ฅผ ๊ฐ๊ฐ 11, 7์ด๋ผ๊ณ  ๊ฐ€์ •ํ•˜๋ฉด 5๋“ฑ์— ๋‹น์ฒจ๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
    • 5๋“ฑ์„ ๋งŒ๋“œ๋Š” ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•๋“ค๋„ ์กด์žฌํ•ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ, 6๋“ฑ(๋‚™์ฒจ)์œผ๋กœ ๋งŒ๋“œ๋Š” ๊ฒƒ์€ ๋ถˆ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

๋ฏผ์šฐ๊ฐ€ ๊ตฌ๋งคํ•œ ๋กœ๋˜ ๋ฒˆํ˜ธ๋ฅผ ๋‹ด์€ ๋ฐฐ์—ด lottos, ๋‹น์ฒจ ๋ฒˆํ˜ธ๋ฅผ ๋‹ด์€ ๋ฐฐ์—ด win_nums๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค. ์ด๋•Œ, ๋‹น์ฒจ ๊ฐ€๋Šฅํ•œ ์ตœ๊ณ  ์ˆœ์œ„์™€ ์ตœ์ € ์ˆœ์œ„๋ฅผ ์ฐจ๋ก€๋Œ€๋กœ ๋ฐฐ์—ด์— ๋‹ด์•„์„œ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

 

์ œํ•œ ์กฐ๊ฑด
  • lottos๋Š” ๊ธธ์ด 6์ธ ์ •์ˆ˜ ๋ฐฐ์—ด์ž…๋‹ˆ๋‹ค.
  • lottos์˜ ๋ชจ๋“  ์›์†Œ๋Š” 0 ์ด์ƒ 45 ์ดํ•˜์ธ ์ •์ˆ˜์ž…๋‹ˆ๋‹ค.
    • 0์€ ์•Œ์•„๋ณผ ์ˆ˜ ์—†๋Š” ์ˆซ์ž๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.
    • 0์„ ์ œ์™ธํ•œ ๋‹ค๋ฅธ ์ˆซ์ž๋“ค์€ lottos์— 2๊ฐœ ์ด์ƒ ๋‹ด๊ฒจ์žˆ์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
    • lottos์˜ ์›์†Œ๋“ค์€ ์ •๋ ฌ๋˜์–ด ์žˆ์ง€ ์•Š์„ ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.
  • win_nums์€ ๊ธธ์ด 6์ธ ์ •์ˆ˜ ๋ฐฐ์—ด์ž…๋‹ˆ๋‹ค.
  • win_nums์˜ ๋ชจ๋“  ์›์†Œ๋Š” 1 ์ด์ƒ 45 ์ดํ•˜์ธ ์ •์ˆ˜์ž…๋‹ˆ๋‹ค.
    • win_nums์—๋Š” ๊ฐ™์€ ์ˆซ์ž๊ฐ€ 2๊ฐœ ์ด์ƒ ๋‹ด๊ฒจ์žˆ์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
    • win_nums์˜ ์›์†Œ๋“ค์€ ์ •๋ ฌ๋˜์–ด ์žˆ์ง€ ์•Š์„ ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

 

์ž…์ถœ๋ ฅ ์˜ˆ
lottos win_nums result
[44, 1, 0, 0, 31, 25] [31, 10, 45, 1, 6, 19] [3, 5]
[0, 0, 0, 0, 0, 0] [38, 19, 20, 40, 15, 25] [1, 6]
[45, 4, 35, 20, 3, 9] [20, 9, 3, 45, 4, 35] [1, 1]

 

๋‚ด ๋ฌธ์ œ ํ’€์ด
import Foundation

func solution(_ lottos:[Int], _ win_nums:[Int]) -> [Int] {
    var count = 0
    var plusCount = 0
    var max = 0
    var min = 0
    
    for i in 0..<lottos.count {
        if win_nums.contains(lottos[i]) { count += 1 }
        else if lottos[i] == 0 { plusCount += 1 }
    }
    
    plusCount+count <= 1 ? (max = 6) : (max = 7 - (plusCount+count))
    count <= 1 ? (min = 6) : (min = 7 - count)
    
    return [max, min]
}
  • ๋‚ด๊ฐ€ ๊ฐ€์ง„ ๋กœ๋˜ ๋ฒˆํ˜ธ๋ฅผ ๊ฒ€์‚ฌํ•˜๋ฉด์„œ ๋‹น์ฒจ ๋ฒˆํ˜ธ์— ํ•ด๋‹นํ•˜๋Š” ์ˆ˜๊ฐ€ ์žˆ์œผ๋ฉด count์— 1์”ฉ ๋”ํ•ด์ฃผ์—ˆ์Œ.
  • ๋‚ด๊ฐ€ ๊ฐ€์ง„ ๋กœ๋˜ ๋ฒˆํ˜ธ๋ฅผ ๊ฒ€์‚ฌํ•˜๋ฉด์„œ 0์ธ ์ˆ˜(๋™์ƒ์ด ๋‚™์„œํ•œ ์ˆ˜)๊ฐ€ ์žˆ์œผ๋ฉด plusCount์— 1์”ฉ ๋”ํ•ด์ฃผ์—ˆ์Œ.
  • ๋‚ด๊ฐ€ ์–ป์„ ์ˆ˜ ์žˆ๋Š” ์ตœ์ € ์ˆœ์œ„๋Š” 0์ธ ์ˆ˜๊ฐ€ ๋ชจ๋‘ ํ‹€๋ ธ์„ ๋•Œ์ด๋‹ˆ, count์— ํ•ด๋‹นํ•˜๋Š” ์ˆœ์œ„๋ฅผ min์— ์ €์žฅํ–ˆ์Œ.
  • ๊ฐ€๋Šฅํ•œ ์ตœ๊ณ  ์ˆœ์œ„๋Š” 0์ธ ์ˆ˜๊ฐ€ ๋ชจ๋‘ ๋งž์•˜์„ ๋•Œ. ๋”ฐ๋ผ์„œ plusCount๋ฅผ plus์— ๋”ํ•ด์ฃผ์–ด ํ•ด๋‹นํ•˜๋Š” ์ˆœ์œ„๋ฅผ max์— ์ €์žฅํ•จ.

 

์ธ์ƒ์ ์ธ ํ’€์ด
import Foundation

func solution(_ lottos:[Int], _ win_nums:[Int]) -> [Int] {

    let zeroCount = lottos.filter { $0 == 0}.count
    let winCount: Int = win_nums.filter { lottos.contains($0) }.count


    return [min(7-winCount-zeroCount,6), min(7-winCount,6)]
}
  • filter๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๊ฐ„๊ฒฐํ•˜๊ฒŒ ํ‘œํ˜„ํ–ˆ๋‹ค,!

 

๐Ÿ’ก ํ”ผ๋“œ๋ฐฑ
  • ์ธ์ƒ์ ์ธ ํ’€์ด๊ฐ€ ๋‚ด ํ’€์ด์™€ ๋กœ์ง์€ ๋น„์Šทํ–ˆ์ง€๋งŒ, filter๋ฅผ ์‚ฌ์šฉํ•จ์œผ๋กœ์จ ํ›จ์”ฌ ๊ฐ„๊ฒฐํ•˜๊ฒŒ ํ‘œํ˜„ํ–ˆ๋‹ค.
  • ์—ญ์‹œ ์กฐ๊ฑด์— ๋”ฐ๋ผ ๊ฒ€์ƒ‰ํ•˜๋Š” ๋ถ€๋ถ„์€ filter๋ฅผ ์ž˜ ์‚ฌ์šฉํ•˜๋ฉด ํšจ๊ณผ์ ์ด๋‹ค,,!!

 


 

๋ฌธ์ œ

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

๋Œ“๊ธ€