[Swift] [15일차] 괄호 회전하기

programmers-괄호 회전하기

문자열 길이만큼 회전 + 올바른지 판단

1. 문자열 길이 만큼 회전은 반복문으로 해주면 되겠고,
2. 올바른지 판단은 별도의 함수를 만들어서 일단 해보자

Prefix, Suffix 사용하기

prefix란 ?

문자열에 주어진 인덱스 전까지 잘라주는 메소드 !

예제코드

var a = "ABCDE
print(a.prefix(3))  // "ABC"

---

suffix란?

prefix의 반대, 뒤에서부터 3만큼 짤라준다!

예제코드

var a = "ABCDE
print(a.suffix(3)) // CDE

---

문자열 회전하기 !

이제 이 두가지를 묶어서 다음과 같이 코드를 짜보면
짤라진친구들을 붙여서 ,이렇게 문자열을 회전시키는 것 처럼 연출할 수 있다. 더 좋은 방법이 있을 수도 있겠지만, 일단은 이렇게 알아낸거로 짜주자
보니까 인덱스를 가공하면서 인자로 넣어주면 원하는대로 나올 것 같다.

print(a.suffix(5) + a.prefix(0))  ABCDE
print(a.suffix(4) + a.prefix(1))  BCDEA
print(a.suffix(3) + a.prefix(2))  CDEAB
print(a.suffix(2) + a.prefix(3))  DEABC
print(a.suffix(1) + a.prefix(4))  EABCD

활용해서 핵심 뼈대를 다음과 같이 잡았다.

 for i in 0 ..< changableString.count {
        let tempString = changableString.suffix(changableString.count - i) + changableString.prefix(i)
        if isRightString(String(tempString)) {
            answer += 1
        }
    }

---

괄호 판단 함수 (with 스택)

switch문을 활용하면 쉼표로 조건을 한번에 묶어줄 수가 있어서 이렇게 구현을 해봤다. 그리고 짝 맞추기 위해 딕셔너리도 이렇게 선언을 해줬다.

let dict: [Character: Character] = [
        ")": "(",
        "]": "[",
        "}": "{"
    ]

func isRightString(_ str: String) -> Bool {
        var stack = [Character]()
        for item in str {
            switch item {
            case "(", "[", "{":
                stack.append(item)
            case ")", "]", "}":
                if stack.isEmpty {
                    return false
                }
                else {
                    if stack.last! == dict[item] {
                        stack.removeLast()
                    }
                    else {
                        return false
                    }
                }
            default:
                continue
            }
        }
        if stack.isEmpty {
            return true
        }
        return false
    }

그렇게해서 이제 isRightString()이 true일때마다 answer을 +1 해주면 완성!

완성코드

import Foundation

func solution(_ s: String) -> Int {
    let dict: [Character: Character] = [
        ")": "(",
        "]": "[",
        "}": "{"
    ]

    var changableString = s
    var answer = 0

    for i in 0 ..< changableString.count {
        let tempString = changableString.suffix(changableString.count - i) + changableString.prefix(i)
//        print(tempString)

        if isRightString(String(tempString)) {
            answer += 1
        }
    }

    func isRightString(_ str: String) -> Bool {
        var stack = [Character]()
        for item in str {
            switch item {
            case "(", "[", "{":
                stack.append(item)
            case ")", "]", "}":
                if stack.isEmpty {
                    return false
                }
                else {
                    if stack.last! == dict[item] {
                        stack.removeLast()
                    }
                    else {
                        return false
                    }
                }
            default:
                continue
            }
        }
        if stack.isEmpty {
            return true
        }
        return false
    }
    return answer
}

채점 결과

정확성: 100.0
합계: 100.0 / 100.0

---

타인의 코드

import Foundation

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로 한번에 묶어준 것도 신기했고, replacingOccurences로 해당하는 문자열을 공백처리해주면서 엄청 간단하게 처리를 해준 것을 볼 수 있었다.