Chikong

문제

풀이 코드

let inputs = readLine()!.map{String($0)}
var answer = 0
var stick = 0

for index in 0..<inputs.count {
    if inputs[index] == "(" {
        stick += 1
    } else {
        stick -= 1
        if inputs[index - 1] == "(" {
            answer += stick
        } else {
            answer += 1
        }
    }
}

print(answer)

풀이 과정

그림을 그려가며 규칙을 찾았다.

레이저를 만나면 막대의 수는 레이저 + 1개가 된다.

그렇게 생각하고 문제를 해결 하려 했는데 도저히 감이 안왔다.

그렇게 고민을 하다가 결국 검색을 통해 답을 보게 되었다.. ㅠㅠ

코드의 흐름대로 보면 다음과 같은 단계로 갯수를 셀 수 있다

1. '(' 를 만나면 막대의 수를 +1 한다.

2. ')'를 만나면 막대의 수를 -1 한다.

2 - 1. ')'를 만났을때 바로 전의 요소가 '('면 레이저를 만났다는 소리가 되고, 레이저를 만나면 현재까지 쌓인 막대의 수 만큼 저장된다

2 - 2 ')'를 만나고, 해당 요소가 레이저가 아니라면, 막대의 마지막 부분이기 때문에 잘린상태의 막대가 +1 된다 ( 레이저 + 1의 규칙이 여기서 적용 )

글로 설명이 어려울거 같아 그림도 같이 첨부하지만..

그림을 봐도 이해를 못할거 같다 이문제는 나중에 코드를 까먹었을때 다시 한번 스스로 풀어보는걸로..

문제

풀이 코드

let inputs = readLine()!
var noReverse = ""
var total = ""

for w in inputs {
    if w == "<" {
        noReverse.append(w)
        if !total.isEmpty {
            reversePrint(total, nil)
            total = ""
        }
    } else if w == ">" {
        noReverse.append(w)
        print(noReverse, terminator: "")
        noReverse = ""
    } else {
        if noReverse.first == "<" {
            noReverse.append(w)
        } else if w != " "{
            total.append(w)
        } else {
            reversePrint(total, " ")
            total = ""
        }
    }
}

if !total.isEmpty {
    reversePrint(total, nil)
}

func reversePrint(_ total: String, _ space: String?) {
    print(String(total.reversed()), terminator: space ?? "")
}

풀이 과정

고민을 많이 했던 문제였다.

처음에는 공백을 기준으로 나누고 단어에 '<' 나 '>' 가 포함되어 있으면 그대로 출력하고,

그렇지 않으면 reversed를 사용하여 뒤집어 출력하게 시도했다.

하지만 이렇게 하면

" <hel le>le <     dsa   >dlae "

이런 형식일때, 제대로 출력하지 못하게 되었고, 고민을 하다가 스택을 이용해서 요소 하나하나를 꺼내주고 < 와 >를 만날때 적절히 처리해야하나..? 고민을 했다.

그러다가 그냥 if 문을 사용하여 구현하기로 했다.

< 가 있다면 별도의 string 에 해당 문자를 넣어주고,

> 를 만나면 문자가 들어있는 문자열을 출력해주고 해당 문자열을 비워 주었다.

그렇지 않은 경우 또 다른 문자열에 넣어 주었고, " " 의 공백을 만나는 기점으로 반전하여 출력하고, 해당문자열을 비워 주었다.

그렇게만 하고 시도 했지만 틀렸다는 결과를 보았고,

< 를 만나기 전, 반전해야 하는 문자가 들어있는 문자열이 비워있지 않으면 반전시켜 출력하고 해당 문자열을 비워주어야 했고,

Loop 가 종료되는 시점에서도 해당 문자열에 문자요소가 남아있다면 비워주어야 했다.

문제

풀이 코드

struct Deque<T> {
    private var elements: [T] = []
    
    public var size: Int {
        return elements.count
    }
    
    public var empty: Int {
        return elements.isEmpty ? 1 : 0
    }
    
    public func front() -> T? {
        return self.elements.first
    }
    
    public func back() -> T? {
        return self.elements.last
    }
    
    public mutating func push_front(_ element: T) {
        return elements.insert(element, at: 0)
    }
    
    public mutating func push_back(_ element: T) {
        return elements.append(element)
    }
    
    public mutating func pop_front() -> T? {
        return elements.isEmpty ? nil : elements.removeFirst()
    }
    
    public mutating func pop_back() -> T? {
        return elements.isEmpty ? nil : elements.removeLast()
    }
}

let N = Int(readLine()!)!
var intQueue = Deque<Int>()

for _ in 0..<N {
    let inputs = readLine()!.split(separator: " ")
    switch inputs[0] {
    case "push_front":
        intQueue.push_front(Int(inputs[1])!)
    case "push_back":
        intQueue.push_back(Int(inputs[1])!)
    case "pop_front":
        print(intQueue.pop_front() ?? -1)
    case "pop_back":
        print(intQueue.pop_back() ?? -1)
    case "size":
        print(intQueue.size)
    case "empty":
        print(intQueue.empty)
    case "front":
        print(intQueue.front() ?? -1)
    default:
        print(intQueue.back() ?? -1)
    }
}

풀이 과정

Front 와 Back 을 구분하는것 이외에는 큐 문제와 완전 똑같았다,

채점결과 한번 틀렸는데

front 와 back 개념을 잘못 설정했다 .. 머쓱 ^^

back 함수들을 추가하여

insert(item, at: index) 를 통해 첫 요소에 값을 넣어 push_front 를 구성 하였고,

removeLast 함수를 사용해 마지막 요소를 제거해 주었다

문제

풀이 코드

var result = [Int]()
let inputs = readLine()!.split(separator: " ")
var num: [Int] = Array(1...Int(inputs[0])!)
var idx = Int(inputs[1])! - 1

while true {
    result.append(num.remove(at: idx))
    if num.isEmpty { break }
    idx = (idx + Int(inputs[1])! - 1) % num.count
}
print("<\(result.map({ String($0)}).joined(separator: ", "))>")

풀이 과정

문제를 이해하는데 그림을 그려야 했다.. 그래서 발로 그린듯한 그림을..

이렇게 원형으로 앉아있을때 K번 순으로 제거하는 문제였다

K번째를 셀때, 제거된 자리는 건너뛰고 세어야 한다!! 

코드에서 inputs[0] 에는 N 이,  inputs[1] 에는 K 가 들어간다.

그리고 나서 규칙을 찾기위해 열심히.. 그림을 그렸다

처음 idx 는 K - 1 ( 인덱스는 0부터 시작하기 때문!! ) 가 되고,

이후로 제거할때 마다 idx 를 바꿔줘야 하는데, 어떻게 바꿀지를 그리면서 고민한 결과 규칙을 찾았다!

1. 우선 idx 인덱스 요소를 제거한다

2. 현재 idx 의 값에 K-1 을 더한후, 제거후 남은 배열의 갯수로 나눈 나머지로 재설정한다 ( idx = (idx + (k-1)) % Array.count )

3. 무한 루프로 돌되, 제거후 배열이 비어 있는 상태가 되면 루프를 종료시킨다!

알고나면 간단한 문제였다..

이래서 그리면서 생각하는게 중요한가봄..

문제

풀이 코드

struct Queue<T> {
    private var elements: [T] = []
    
    public var size: Int {
        return elements.count
    }
    
    public var empty: Int {
        return elements.isEmpty ? 1 : 0
    }
    
    public func front() -> T? {
        return self.elements.first
    }
    
    public func back() -> T? {
        return self.elements.last
    }
    
    public mutating func push(_ element: T) {
        return elements.append(element)
    }
    
    public mutating func pop() -> T? {
        return elements.isEmpty ? nil : elements.removeFirst()
    }
}

let N = Int(readLine()!)!
var intQueue = Queue<Int>()

for _ in 0..<N {
    let inputs = readLine()!.split(separator: " ")
    switch inputs[0] {
    case "push":
        intQueue.push(Int(inputs[1])!)
    case "pop":
        print(intQueue.pop() ?? -1)
    case "size":
        print(intQueue.size)
    case "empty":
        print(intQueue.empty)
    case "front":
        print(intQueue.front() ?? -1)
    default:
        print(intQueue.back() ?? -1)
    }
}

풀이 과정

Queue에 대한 개념을 학습하고, 이를 Swift 로 구현한 후 문제를 보니 쉽게 다가왔다,

Queue를 정의한 struct를 이용해서 문제를 풀 수 있었다.

그런데 풀이코드와 같은 Queue의 구조를 쓰게되면 메모리 효율이 떨어지기 때문에 다른 방법으로 큐를 구현하여 풀었더니

분명 TastCase 모두 정답이 나왔고, 문제없이 잘 출력 되었는데 틀렸다는 채점결과를 얻게되었다.

아직까지 뭐가 문제인지 모르겠다,, 이것저것 테스트를 해보았지만 정상적으로 값이 출력되었는데 도저히 모르겠다.

혹시나 해서 메모리 효율을 무시하고 그냥 원래의 방식대로 풀었더니 맞았다고 나왔다..

출력 결과는 같은데 도대체 뭐가 다른건지.. 도저히 모르겠다..

문제의 코드

struct Queue<T> {
    private var elements: [T?] = []
    private var head = 0
    
    public var size: Int {
        var numberOfNonNilValues = 0
        for case .some in elements { numberOfNonNilValues += 1 }
        return numberOfNonNilValues
    }
    
    public var empty: Int {
        return elements.isEmpty ? 1 : 0
    }
    
    public func front() -> T? {
        return self.elements.first ?? nil
    }
    
    public func back() -> T? {
        return self.elements.last ?? nil
    }
    
    public mutating func push(_ element: T) {
        return elements.append(element)
    }
    
    public mutating func pop() -> T? {
        guard head < elements.count, let element = elements[head] else { return nil }
        elements[head] = nil
        head += 1
        
        if head > (elements.count / 3) {
            elements.removeFirst(head)
            head = 0
        }
        return element
    }
}

let N = Int(readLine()!)!
var intQueue = Queue<Int>()
var element: Int?

for _ in 0..<N {
    let inputs = readLine()!.split(separator: " ")
    switch inputs[0] {
    case "push":
        intQueue.push(Int(inputs[1])!)
    case "pop":
        print(intQueue.pop() ?? -1)
    case "size":
        print(intQueue.size)
    case "empty":
        print(intQueue.empty)
    case "front":
        print(intQueue.front() ?? -1)
    default:
        print(intQueue.back() ?? -1)
    }
}