๐ ์ฝ๋ฉํ ์คํธ ๋ฌธ์ ํ์ด
โ๐ป ๋ฌธ์ ํ์ด github ๋งํฌ
๋ฌธ์ ์ค๋ช
๋ค์ ๊ท์น์ ์งํค๋ ๋ฌธ์์ด์ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ผ๊ณ ์ ์ํฉ๋๋ค.
- (), [], {} ๋ ๋ชจ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค.
- ๋ง์ฝ A๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ผ๋ฉด, (A), [A], {A} ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค. ์๋ฅผ ๋ค์ด, [] ๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ฏ๋ก, ([]) ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค.
- ๋ง์ฝ A, B๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ผ๋ฉด, AB ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค. ์๋ฅผ ๋ค์ด, {} ์ ([]) ๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ฏ๋ก, {}([]) ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค.
๋๊ดํธ, ์ค๊ดํธ, ๊ทธ๋ฆฌ๊ณ ์๊ดํธ๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด s๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ด s๋ฅผ ์ผ์ชฝ์ผ๋ก x (0 ≤ x < (s์ ๊ธธ์ด)) ์นธ๋งํผ ํ์ ์์ผฐ์ ๋ s๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด ๋๊ฒ ํ๋ x์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- s์ ๊ธธ์ด๋ 1 ์ด์ 1,000 ์ดํ์ ๋๋ค.
์ ์ถ๋ ฅ ์
s | result |
"{}" | 3 |
"}]()[{" | 2 |
"[)(]" | 0 |
"}}}" | 0 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๋ค์ ํ๋ "[](){}" ๋ฅผ ํ์ ์ํจ ๋ชจ์ต์ ๋ํ๋ธ ๊ฒ์ ๋๋ค.
x | s๋ฅผ ์ผ์ชฝ์ผ๋ก x์นธ๋งํผ ํ์ | ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด? |
0 | "{}" | O |
1 | "](){}[" | X |
2 | "(){}[]" | O |
3 | "){}[](" | X |
4 | "{}" | O |
5 | "}{" | X |
- ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด ๋๋ x๊ฐ 3๊ฐ์ด๋ฏ๋ก, 3์ return ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๋ค์ ํ๋ "}]()[{" ๋ฅผ ํ์ ์ํจ ๋ชจ์ต์ ๋ํ๋ธ ๊ฒ์ ๋๋ค.
x | s๋ฅผ ์ผ์ชฝ์ผ๋ก x์นธ๋งํผ ํ์ | ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด? |
0 | "}]()[{" | X |
1 | "]()[{}" | X |
2 | "()[{}]" | O |
3 | ")[{}](" | X |
4 | "{}" | O |
5 | "{}]()[" | X |
- ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด ๋๋ x๊ฐ 2๊ฐ์ด๋ฏ๋ก, 2๋ฅผ return ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
- s๋ฅผ ์ด๋ป๊ฒ ํ์ ํ๋๋ผ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋ง๋ค ์ ์์ผ๋ฏ๋ก, 0์ return ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #4
- s๋ฅผ ์ด๋ป๊ฒ ํ์ ํ๋๋ผ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋ง๋ค ์ ์์ผ๋ฏ๋ก, 0์ return ํด์ผ ํฉ๋๋ค.
๋ฌธ์ ํ์ด
๋์ ํ์ด
import Foundation
func solution(_ s:String) -> Int {
var s = s
var count = 0
// s์ ๊ธธ์ด๊ฐ ํ์๋ผ๋ฉด ์ด๋ป๊ฒ ํ์ ํ๋๋ผ๋ 0
if s.count % 2 != 0 {
return 0
}
// s๋ฅผ ํ์ ํ๋ฉฐ ๊ดํธ ๋ฌธ์์ด ๋น๊ต
for _ in 1...s.count {
// s๋ฅผ ํ์
var char = s.prefix(1)
s.removeFirst()
s = s + char
var changeStr = s
for _ in 1...s.count/2 {
// ๋ฐ๋์ง ์๋ฐ๋์ง ๋น๊ต ๋ฌธ์์ด
var compareStr = changeStr
changeStr = changeStr.replacingOccurrences(of: "{}", with: "")
changeStr = changeStr.replacingOccurrences(of: "[]", with: "")
changeStr = changeStr.replacingOccurrences(of: "()", with: "")
if changeStr == "" {
count += 1
break
}else if changeStr == compareStr {
break
}
}
}
return count
}
์ฐ์ ‘ํ์ ์ ์ด๋ป๊ฒ ํ์ง’ ๋ผ๋ ์๊ฐ์ ๋จผ์ ํ๊ฒ๋์๋ค. ๋ฌธ์์ด์ ์ต๋ ๊ธธ์ด๊ฐ 10,000์ด๊ธฐ์ ๊ผญ ํ๋ฒ์ for๋ฌธ์ ๋์์ผ ํ๋ค๊ณ ์๊ฐํ๋ค.
๊ทธ๋์ for๋ฌธ์ ๋๋ฉฐ s์ ๋ฌธ์์ด์ ํ์ ํ๊ธฐ ์ํด s์ ์ฒซ ๋ฌธ์๋ฅผ ๊บผ๋ด์ด ๋ณ์์ ์ ์ฅํ ํ ์ฒซ ๋ฌธ์๋ฅผ ์ญ์ ํ๊ณ , ์ด ๋ฌธ์๋ฅผ ๋ค์ ๋ฌธ์์ด ๋ค๋ก ๋ถ์ฌ์ฃผ์๋ค.
์ค๊ดํธ, ๋๊ดํธ, ์๊ดํธ๊ฐ ๋ณด์ธ๋ค๋ฉด ์ด๋ฅผ ๋น๋ฌธ์์ด๋ก ๋ฐ๊พธ๋ replacingOccurrences๋ฅผ ์ฌ์ฉํ์๊ณ , ์ด ๊ณผ์ ์ ๋ฌธ์์ด์ ๊ธธ์ด ๋๋๊ธฐ 2๋งํผ ๋ฐ๋ณตํ์๋ค.
์ด ๊ณผ์ ์์ ์คํ ์๊ฐ์ ์ค์ด๊ธฐ ์ํด ๋ฌธ์์ด์ด ๋น๊ฑฐ๋ ๋ฌธ์์ด์ ๋ณํ๊ฐ ์๋ค๋ฉด ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ๋์ค๋๋ก ๋ก์ง์ ๊ตฌํํ๋ค.
์ด๋ ์๊ฐ์ด๊ณผ๋ฅผ ์ค์ด๊ธฐ ์ํด ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ ํ์๋ผ๋ฉด ๋ฌด์กฐ๊ฑด 0์ด ๋์จ๋ค๋ ์กฐ๊ฑด์ ์ถ๊ฐํด์ฃผ์๋ค.
๋ค๋ฅธ ์ฌ๋ ํ์ด
func solution(_ s:String) -> Int {
var answer: Int = 0
var string = s
var turnString = s
for _ in 1...s.count {
while string.contains("{}") || string.contains("[]") || string.contains("()") {
string = string.replacingOccurrences(of: "{}", with: "")
string = string.replacingOccurrences(of: "()", with: "")
string = string.replacingOccurrences(of: "[]", with: "")
}
if string.count == 0 {
answer += 1
}
string = turnString
string.append(string.removeFirst())
turnString = string
}
return answer
}
contains์ ํ์ฉํด์ ํ๋ฉด ๋ ๊น๋ํ์๊ฑฐ๋ผ๋ ์๊ฐ์ด ๋ค์๋ค.
string.append๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ ์์ฐ๊ณผ ๋์์ ๊ฐ์ ์ถ๊ฐํ์๋ค.
var char = s.prefix(1)
s.removeFirst()
s = s + char
์ด ๋ถ๋ถ์ ์ค์ด๊ณ ์ถ์๋๋ฐ, string์ ํน์ ๋ฌธ์์ด์ ์ถ๊ฐํ๊ธฐ ์ํด์๋ append ๊ฐ์ ์ฌ์ฉํ๋ฉด ๋๋ค๋ผ๋ ๊ฒ์ ๊นจ๋ฌ์๋ค.