๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐Ÿ“– Problem Solution/Programmers

ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค ์ˆซ์ž์•ผ๊ตฌ Swift

by Fomagran ๐Ÿ’ป 2020. 5. 18.
728x90
๋ฐ˜์‘ํ˜•

๋ฌธ์ œ ์„ค๋ช…

์ˆซ์ž ์•ผ๊ตฌ ๊ฒŒ์ž„์ด๋ž€ 2๋ช…์ด ์„œ๋กœ๊ฐ€ ์ƒ๊ฐํ•œ ์ˆซ์ž๋ฅผ ๋งž์ถ”๋Š” ๊ฒŒ์ž„์ž…๋‹ˆ๋‹ค.

๊ฐ์ž ์„œ๋กœ ๋‹ค๋ฅธ 1~9๊นŒ์ง€ 3์ž๋ฆฌ ์ž„์˜์˜ ์ˆซ์ž๋ฅผ ์ •ํ•œ ๋’ค ์„œ๋กœ์—๊ฒŒ 3์ž๋ฆฌ์˜ ์ˆซ์ž๋ฅผ ๋ถˆ๋Ÿฌ์„œ ๊ฒฐ๊ณผ๋ฅผ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ํ† ๋Œ€๋กœ ์ƒ๋Œ€๊ฐ€ ์ •ํ•œ ์ˆซ์ž๋ฅผ ์˜ˆ์ƒํ•œ ๋’ค ๋งžํž™๋‹ˆ๋‹ค.

* ์ˆซ์ž๋Š” ๋งž์ง€๋งŒ, ์œ„์น˜๊ฐ€ ํ‹€๋ ธ์„ ๋•Œ๋Š” ๋ณผ * ์ˆซ์ž์™€ ์œ„์น˜๊ฐ€ ๋ชจ๋‘ ๋งž์„ ๋•Œ๋Š” ์ŠคํŠธ๋ผ์ดํฌ * ์ˆซ์ž์™€ ์œ„์น˜๊ฐ€ ๋ชจ๋‘ ํ‹€๋ ธ์„ ๋•Œ๋Š” ์•„์›ƒ

์˜ˆ๋ฅผ ๋“ค์–ด, ์•„๋ž˜์˜ ๊ฒฝ์šฐ๊ฐ€ ์žˆ์œผ๋ฉด

A : 123 B : 1์ŠคํŠธ๋ผ์ดํฌ 1๋ณผ. A : 356 B : 1์ŠคํŠธ๋ผ์ดํฌ 0๋ณผ. A : 327 B : 2์ŠคํŠธ๋ผ์ดํฌ 0๋ณผ. A : 489 B : 0์ŠคํŠธ๋ผ์ดํฌ 1๋ณผ.

์ด๋•Œ ๊ฐ€๋Šฅํ•œ ๋‹ต์€ 324์™€ 328 ๋‘ ๊ฐ€์ง€์ž…๋‹ˆ๋‹ค.

์งˆ๋ฌธํ•œ ์„ธ ์ž๋ฆฌ์˜ ์ˆ˜, ์ŠคํŠธ๋ผ์ดํฌ์˜ ์ˆ˜, ๋ณผ์˜ ์ˆ˜๋ฅผ ๋‹ด์€ 2์ฐจ์› ๋ฐฐ์—ด baseball์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, ๊ฐ€๋Šฅํ•œ ๋‹ต์˜ ๊ฐœ์ˆ˜๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•ด์ฃผ์„ธ์š”.

์ œํ•œ์‚ฌํ•ญ

  • ์งˆ๋ฌธ์˜ ์ˆ˜๋Š” 1 ์ด์ƒ 100 ์ดํ•˜์˜ ์ž์—ฐ์ˆ˜์ž…๋‹ˆ๋‹ค.
  • baseball์˜ ๊ฐ ํ–‰์€ [์„ธ ์ž๋ฆฌ์˜ ์ˆ˜, ์ŠคํŠธ๋ผ์ดํฌ์˜ ์ˆ˜, ๋ณผ์˜ ์ˆ˜] ๋ฅผ ๋‹ด๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ

baseball return
[[123, 1, 1], [356, 1, 0], [327, 2, 0], [489, 0, 1]] 2

ํ’€์ด: ์ด๋ฒˆ ๋ฌธ์ œ๋Š” ์™„์ „ํƒ์ƒ‰์ž…๋‹ˆ๋‹ค.

3์ž๋ฆฌ ์ˆ˜์ด๊ณ  ์ค‘๋ณต์ด ์—†์œผ๋ฉฐ(๊ฐ์ž ์„œ๋กœ ๋‹ค๋ฅธ) 0(1~9)์ด ํฌํ•จ๋˜์ง€ ์•Š์€ ๋ชจ๋“  ์ˆซ์ž๋ฅผ ํƒ์ƒ‰ํ•ฉ๋‹ˆ๋‹ค.

๋จผ์ € answer์„ baseball์•ˆ์˜ ๋ฐฐ์—ด์˜ ์ˆซ์ž๋งŒํผ ์ด์ค‘๋ฐฐ์—ด์œผ๋กœ ๋งŒ๋“ค์–ด์ค๋‹ˆ๋‹ค. ->  var answer = Array(repeating: [Int](), count: baseball.count)

123~987๊นŒ์ง€์˜ ์ˆซ์ž๋ฅผ map์œผ๋กœ ๋‚˜๋ˆ ์ค๋‹ˆ๋‹ค. ->  let number =  String(i).map{String($0)}

์ด ์ˆซ์ž ์ค‘ 0์ด ํฌํ•จ๋˜์–ด์žˆ๋‹ค๋ฉด -> number.contains("0")

์ค‘๋ณต์ด ์—†๋‹ค๋ฉด -> number[0== number[1|| number[0== number[2|| number[1== number[2]

baseball์•ˆ์˜ ์ˆซ์ž๋งŒํผ for๋ฌธ์„ ๋Œ๋ ค์ค๋‹ˆ๋‹ค. -> for j in 0..<baseball.count{...}

strike์™€ ball์˜ ์ˆ˜๋ฅผ ๋‹ด์„ ๋ณ€์ˆ˜๋ฅผ ๋งŒ๋“ค์–ด์ค๋‹ˆ๋‹ค. ->   var strike = 0,ball = 0

baseball์•ˆ์— 0๋ฒˆ์งธ ์žˆ๋Š” ์ˆซ์ž๋ฅผ map์œผ๋กœ ๋‚˜๋ˆ ์ค๋‹ˆ๋‹ค. -> let baseballmap = String(baseball[j][0]).map{String($0)}

baseball์˜ 0๋ฒˆ์งธ ์ˆซ์ž๊ฐ€ 3์ž๋ฆฌ ์ˆ˜์ด๊ธฐ ๋•Œ๋ฌธ์— for๋ฌธ์œผ๋กœ 0~2๊นŒ์ง€ ๋Œ๋ ค์ค๋‹ˆ๋‹ค. ->  for n in 0...2{...}

number์˜ ์œ„์น˜์™€ baseball์˜ 0๋ฒˆ์งธ ์ˆซ์ž ์œ„์น˜๊ฐ€ ๊ฐ™๋‹ค๋ฉด strike๋ฅผ 1 ์ฆ๊ฐ€์‹œ์ผœ์ค๋‹ˆ๋‹ค. ->  if number[n] == baseballmap[n]{ strike += 1 }

์œ„์น˜๊ฐ€ ๊ฐ™์ง€ ์•Š์ง€๋งŒ ๊ทธ baseball์˜ 0๋ฒˆ์งธ ์ˆซ์ž๋ฅผ ๋งต์œผ๋กœ ๋‚˜๋ˆˆ ์ˆซ์ž ์ค‘ number์•ˆ์˜ ์ˆซ์ž๊ฐ€ ํฌํ•จ๋˜์–ด ์žˆ๋‹ค๋ฉด ball์„ 1 ์ฆ๊ฐ€์‹œ์ผœ์ค๋‹ˆ๋‹ค. -> else{ if baseballmap.contains(number[n]){ ball += 1 }}

๊ทธ๋ฆฌ๊ณค baseball์˜ ๋ฐฐ์—ด ์ค‘ 1๋ฒˆ์งธ ์ˆซ์ž์™€ strike๊ฐ€ ๊ฐ™๊ณ  baseball์˜ 2๋ฒˆ์งธ ์ˆซ์ž๊ฐ€ ball๊ณผ ๊ฐ™๋‹ค๋ฉด if baseball[j][1== strike && baseball[j][2== ball{...}

๋งˆ์ง€๋ง‰์œผ๋กœ ๊ฐ ๋ฐฐ์—ด์— ๋‹ด๊ฒจ์žˆ๋Š” ๊ฐ€๋Šฅํ•œ ์ˆซ์ž๋“ค ์ค‘ ๊ณตํ†ต๋œ ์ˆซ์ž๋งŒ ๋ชจ์œผ๊ธฐ ์œ„ํ•ด ->   if j == 0 { answer[j].append(i) }else { if answer[j-1].contains(i){ answer[j].append(i) }} ๋ฅผ ํ•ด์ค€ ๋’ค answer์˜ ๋งจ ๋งˆ์ง€๋ง‰๋ฐฐ์—ด์˜ ์ˆซ์ž๋ฅผ returnํ•ด์ค๋‹ˆ๋‹ค.

 

์ „์ฒด์ฝ”๋“œ

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
29
30
31
32
33
34
import Foundation
 
func solution(_ baseball:[[Int]]) -> Int {
    var answer = Array(repeating: [Int](), count: baseball.count)
    for i in 123...987{
        let number =  String(i).map{String($0)}
        if number[0== number[1|| number[0== number[2|| number[1== number[2|| number.contains("0"){
            continue
        }
        for j in 0..<baseball.count{
             var strike = 0,ball = 0
            let baseballmap = String(baseball[j][0]).map{String($0)}
            for n in 0...2{
                if number[n] == baseballmap[n]{
                    strike += 1
                }else{
                    if baseballmap.contains(number[n]){
                    ball += 1
                    }
                }
            }
            if baseball[j][1== strike && baseball[j][2== ball{
                if j == 0 {
                answer[j].append(i)
                }else{
                    if answer[j-1].contains(i){
                        answer[j].append(i)
                    }
                }
            }
        }
    }
    return answer[answer.count-1].count
}
cs

 

 

 

 

 

728x90
๋ฐ˜์‘ํ˜•

๋Œ“๊ธ€