ํ๋ก๊ทธ๋๋จธ์ค LV.1 ๋ชจ์
๋คํธ ๊ฒ์
๋ฌธ์ ์ค๋ช
์นด์นด์คํก์ ๋ฌ ๋ค ๋ฒ์งธ ๋ณ! ์ฌ์ฌํ ๋? ์นด์นด์คํก ๊ฒ์๋ณ~
์นด์นด์คํก ๊ฒ์๋ณ์ ํ๋ฐ๊ธฐ ์ ๊ท ์๋น์ค๋ก ๋คํธ ๊ฒ์์ ์ถ์ํ๊ธฐ๋ก ํ๋ค. ๋คํธ ๊ฒ์์ ๋คํธํ์ ๋คํธ๋ฅผ ์ธ ์ฐจ๋ก ๋์ ธ ๊ทธ ์ ์์ ํฉ๊ณ๋ก ์ค๋ ฅ์ ๊ฒจ๋ฃจ๋ ๊ฒ์์ผ๋ก, ๋ชจ๋๊ฐ ๊ฐ๋จํ ์ฆ๊ธธ ์ ์๋ค. ๊ฐ ์ ์ฌํ ๋ฌด์ง๋ ์ฝ๋ฉ ์ค๋ ฅ์ ์ธ์ ๋ฐ์ ๊ฒ์์ ํต์ฌ ๋ถ๋ถ์ธ ์ ์ ๊ณ์ฐ ๋ก์ง์ ๋งก๊ฒ ๋์๋ค. ๋คํธ ๊ฒ์์ ์ ์ ๊ณ์ฐ ๋ก์ง์ ์๋์ ๊ฐ๋ค.
- ๋คํธ ๊ฒ์์ ์ด 3๋ฒ์ ๊ธฐํ๋ก ๊ตฌ์ฑ๋๋ค.
- ๊ฐ ๊ธฐํ๋ง๋ค ์ป์ ์ ์๋ ์ ์๋ 0์ ์์ 10์ ๊น์ง์ด๋ค.
- ์ ์์ ํจ๊ป Single(S), Double(D), Triple(T) ์์ญ์ด ์กด์ฌํ๊ณ ๊ฐ ์์ญ ๋น์ฒจ ์ ์ ์์์ 1 ์ ๊ณฑ, 2 ์ ๊ณฑ, 3 ์ ๊ณฑ (์ ์ 1 , ์ ์ 2 , ์ ์ 3 )์ผ๋ก ๊ณ์ฐ๋๋ค.
- ์ต์ ์ผ๋ก ์คํ์(*) , ์์ฐจ์(#)์ด ์กด์ฌํ๋ฉฐ ์คํ์(*) ๋น์ฒจ ์ ํด๋น ์ ์์ ๋ฐ๋ก ์ ์ ์ป์ ์ ์๋ฅผ ๊ฐ 2๋ฐฐ๋ก ๋ง๋ ๋ค. ์์ฐจ์(#) ๋น์ฒจ ์ ํด๋น ์ ์๋ ๋ง์ด๋์ค๋๋ค.
- ์คํ์(*)์ ์ฒซ ๋ฒ์งธ ๊ธฐํ์์๋ ๋์ฌ ์ ์๋ค. ์ด ๊ฒฝ์ฐ ์ฒซ ๋ฒ์งธ ์คํ์(*)์ ์ ์๋ง 2๋ฐฐ๊ฐ ๋๋ค. (์์ 4๋ฒ ์ฐธ๊ณ )
- ์คํ์(*)์ ํจ๊ณผ๋ ๋ค๋ฅธ ์คํ์(*)์ ํจ๊ณผ์ ์ค์ฒฉ๋ ์ ์๋ค. ์ด ๊ฒฝ์ฐ ์ค์ฒฉ๋ ์คํ์(*) ์ ์๋ 4๋ฐฐ๊ฐ ๋๋ค. (์์ 4๋ฒ ์ฐธ๊ณ )
- ์คํ์(*)์ ํจ๊ณผ๋ ์์ฐจ์(#)์ ํจ๊ณผ์ ์ค์ฒฉ๋ ์ ์๋ค. ์ด ๊ฒฝ์ฐ ์ค์ฒฉ๋ ์์ฐจ์(#)์ ์ ์๋ -2๋ฐฐ๊ฐ ๋๋ค. (์์ 5๋ฒ ์ฐธ๊ณ )
- Single(S), Double(D), Triple(T)์ ์ ์๋ง๋ค ํ๋์ฉ ์กด์ฌํ๋ค.
- ์คํ์(*), ์์ฐจ์(#)์ ์ ์๋ง๋ค ๋ ์ค ํ๋๋ง ์กด์ฌํ ์ ์์ผ๋ฉฐ, ์กด์ฌํ์ง ์์ ์๋ ์๋ค.
0~10์ ์ ์์ ๋ฌธ์ S, D, T, *, #๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ด์ด ์ ๋ ฅ๋ ์ ์ด์ ์๋ฅผ ๋ฐํํ๋ ํจ์๋ฅผ ์์ฑํ๋ผ.
์ ๋ ฅ ํ์
"์ ์|๋ณด๋์ค|[์ต์ ]"์ผ๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด 3์ธํธ.
ex) 1S2D*3T
- ์ ์๋ 0์์ 10 ์ฌ์ด์ ์ ์์ด๋ค.
- ๋ณด๋์ค๋ S, D, T ์ค ํ๋์ด๋ค.
- ์ต์ ์ *์ด๋ # ์ค ํ๋์ด๋ฉฐ, ์์ ์๋ ์๋ค.
์ถ๋ ฅ ํ์
3๋ฒ์ ๊ธฐํ์์ ์ป์ ์ ์ ํฉ๊ณ์ ํด๋นํ๋ ์ ์๊ฐ์ ์ถ๋ ฅํ๋ค.
ex) 37
์ ์ถ๋ ฅ ์
์ ์ถ
func solution(_ dartResult:String) -> Int {
var current = -1
var ten = 0
var re = [0, 0, 0]
for i in dartResult{
switch i{
case "0"..."9":
if ten == 0{
current += 1
re[current] = Int(String(i))!
}
else{
re[current] = 10
}
if i == "1"{
ten = 1
}
break
case "S":
ten = 0
break
case "D":
ten = 0
re[current] *= re[current]
break
case "T":
ten = 0
re[current] = re[current] * re[current] * re[current]
break
case "*":
if(current == 0){
re[current] *= 2
}else{
re[current-1] *= 2
re[current] *= 2
}
break
case "#":
re[current] *= -1
break
default:
break
}
}
return re.reduce(0,+)
}
switch-case๋ฌธ์ ์ฌ์ฉํ์ฌ ์ ๋ ฅ๋ฐ์ ๋ฌธ์์ด์ ๋ฌธ์์ ๋ฐ๋ผ ๋์์ ์ํํ๋ค.
์ซ์๋ผ๋ฉด re๋ณ์์ ์ ์ฅํ๋ค. (์ซ์๋ 0๋ถํฐ 10๊น์ง ์ด๊ธฐ ๋๋ฌธ์, ten ๋ณ์๋ฅผ ์ฌ์ฉํด ์ซ์๊ฐ 1์ธ๊ฒฝ์ฐ ๋ค์์ 0์ด ๋ผ๋ฉด 10์ ์ ์ฅํ๋ค.)
"D", "T"์ธ ๊ฒฝ์ฐ ๊ฐ๊ฐ ์ ์๋ฅผ 2์ ๊ณฑ, 3์ ๊ณฑํ๋ค.
"*"์ธ ๊ฒฝ์ฐ, ํ์ฌ ์ ์๊ฐ ์ฒซ ๋ฒ์งธ๋ผ๋ฉด ํ์ฌ ์ ์๋ง, ์๋๋ผ๋ฉด ์ด์ ์ ์๊น์ง 2๋ฐฐ ํ๋ค.
"#"์ธ ๊ฒฝ์ฐ, ํ์ฌ ์ ์์ -1์ ๊ณฑํด ์์๋ก ๋ง๋ ๋ค.
์ ์๋ฅผ ์ ์ฅํ re ๋ฐฐ์ด์ reduce๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ฒด ์ ์์ ํฉ์ ๊ตฌํด ๋ฐํํ๋ค.
๋ค๋ฅธ ํ์ด
func solution(_ dartResult:String) -> Int {
let numberList = dartResult.split(whereSeparator: {$0.isLetter || $0 == "#" || $0 == "*"}).map{Int($0)!}
let letterList = dartResult.split(whereSeparator: {$0.isNumber})
var result = [0, 0 ,0]
for (i, (number, letter)) in zip(numberList, letterList).enumerated() {
var n = letter.contains("D") ? number*number : (letter.contains("T") ? number*number*number : number)
if letter.contains("*"){
if i != 0{
result[i-1] *= 2
}
n*=2
}else if letter.contains("#"){
n *= -1
}
result[i] = n
}
return result.reduce(0, +)
}
์ ๋ ฅ๋ฐ์ ๋ฌธ์์ด์ ์ซ์๋ง ์๋ ์ ์ํ ๋ฐฐ์ด numberList์ ๋ฌธ์๋ก๋ง ๊ตฌ์ฑ๋ Stringํ ๋ฐฐ์ด letterList๋ฅผ ์์ฑํ๋ค.
ex) 1S2D*3T
numberList = [1, 2, 3]
letterList = ["S", "D*", "T"]
numberList์ letterList๋ฅผ zip์ ์ฌ์ฉํ์ฌ ๊ฒฐํฉํ๋ค.
๋ฌธ์์ D๊ฐ ์๋ค๋ฉด 2์ ๊ณฑ, T๊ฐ ์๋ค๋ฉด 3์ ๊ณฑํ๋ค.
๋ฌธ์์ "*"์ด ์๋ ๊ฒฝ์ฐ, ํ์ฌ index๊ฐ 0์ด ์๋๋ผ๋ฉด ์ด์ ์ ์์ 2๋ฅผ ๊ณฑํ ํ, ํ์ฌ ์ ์์ 2๋ฅผ ๊ณฑํ๋ค.
๋ฌธ์์ "#"์ด ์๋ค๋ฉด ํ์ฌ ์ ์์ -1์ ๊ณฑํด ์์๋ก ๋ง๋ ๋ค.
ํ์ฌ ์ ์๋ฅผ result ๋ฐฐ์ด์ ์ ์ฅํ๋ค.
result ๋ฐฐ์ด์ reduce๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ฒด ์ ์์ ํฉ์ ๊ตฌํ ํ ๋ฐํํ๋ค.
'โจ๏ธ Language > swift' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ๋ชจ์๊ณ ์ฌ (0) | 2023.02.22 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] K๋ฒ์งธ์ (0) | 2023.02.22 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ๋น๋ฐ์ง๋ (0) | 2023.02.21 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ์์ฐ (0) | 2023.02.16 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ์์ ๋ง๋ค๊ธฐ (0) | 2023.02.16 |