Link of Problem

LEVEL : 🌕 🌕 🌕 🌑 🌑 (중)

Anagrams, 단어나 문장을 구성하고 있는 문자의 순서를 바꾸어 다른 단어나 문장을 만드는 놀이 라고 합니다. 이름 그대로 Character의 순서만 바뀌면 같은 단어가 되는 element들끼리 묶는 문제였어요.

저는 어떻게 접근해야할지도 모르겠고, 도저히 감이 잡히지 않아서 Solution에 또 손을 댔습니다...🥲 정말로 모르겠더라구요...🥲

또 새로운 방법을 얻어갑니다.

Solution

제 생각보다 너무너무너무너무 x 100 간단했던 방식이었습니다.

정말 짧지 않나요? 제가 머릿속으로 그리고 처음에 짰던 코드가 미완성인 상태라도 저것보다 길었는데... 자괴감이 드네요.

func groupAnagrams(_ strs: [String]) -> [[String]] {
    guard strs.count > 1 else { return [strs] }

    var map = [String: [String]]()

    for str in strs {
        let key = String(str.sorted())
        map[key, default: []].append(str)
    }

    return Array(map.values)
}

이 코드는 Dictionary를 특이하게 사용했습니다. [String: [String]] : key를 String으로 value를 String 배열로 잡았어요.

요 부분만 보고는 저도 어떻게 할 생각인가 싶었는데, 밑에 for문을 보게 되면 str를 하나씩 가져오면서 key값을 sorted로 일정하게 만듭니다. 한 마디로 eat와 ate 모두 sorted된 상태가 aet이기 때문에 두 개 모두 key값을 aet로 가지게 되는거죠. 그렇기 때문에 anagrams로 인식이 되어서 같은 value로 들어갑니다.

제가 생각한 것보다 훨씬 쉽게 풀리던거였습니다...🥲 하지만 저렇게 Dictionary를 쓸 수 있다는 것, Dictionary에서의 default사용을 할 수 있다는 것, 이런걸 처음 알았네요.. 다음부터는 풀이에 사용해봐야겠습니다.

Link of Problem

LEVEL : 🌕 🌕 🌑 🌑 🌑 (하)

Easy Collection String의 세번째 문제인 First Unique Character in a String를 풀어봤습니다.

이번 문제는 String 속에서 한 번만 나타나는 Character를 찾고 해당 Character의 index를 return하는 문제였습니다.

저는 문제를 보자마자 Stack를 사용하면 되겠다! 했는데, 중복이라는 게 2개만 있는 게 아닌데 2개라고 안일하게 생각해버린거였습니다.. 3개도 나올 수 있고 4,5.. 무한정으로 등장할 수 있기 때문에 Stack은 절대 알맞지 않더라구요.

대신 다른 방법들을 찾아봤습니다.

1️⃣ 번째 방법

첫 번째 방법은 Dictionary를 사용했습니다.

두 개의 Dictionary를 만들었는데요, 첫 번째는 Character가 나오는 Count를 세는 용, 두 번째는 Character의 index를 저장하는 용으로 만들었어요. 두 개로 나눈 이유는 Dictionary에는 순서가 없어서, 하나씩 찬찬히 넣어줘도 뒤죽박죽이 되어 버립니다...😂

일단 첫 번째 for문을 통해서 s에 포함되어 있는 character가 lists에 key값으로 포함되어 있는지 보고,

없으면 해당 key값을 넣고 value로 0를 넣어줍니다. 그리고 indexs에는 해당 값이 들어온 적이 없다면 index값을 value로 넣어줍니다. 있으면 해당 char를 가지고 있는 value값을 +1 해줍니다.

그리고 두 번째 for문에서는 indexs도 마찬가지로 뒤죽박죽이기 때문에 value를 중심으로 sort를 먼저해주고 그에 맞춰서 key값과 index값을 꺼냅니다. 꺼낸 key값이 list에서 0를 출력한다면 그 index를 return해줍시다.

두 번째 for문에서 return되지 못했다면 모든 character가 중복이라는 뜻이기 때문에 -1를 return하면 됩니다.

func firstUniqChar(_ s: String) -> Int {
    var lists: [Character: Int] = [:]
    var indexs: [Character: Int] = [:]

    for (index, char) in s.enumerated() {
        if lists.keys.contains(char) {
            if let num = lists[char] {
                lists.updateValue(num+1, forKey: char)
            }
        } else {
            lists[char] = 0
            if !indexs.keys.contains(char) {
                indexs[char] = index
            }
        }
    }

    for (key, index) in indexs.sorted(by: { $0.1 < $1.1 }) {
        if lists[key] == 0 {
            return index
        }
    }

    return -1
}

Runtime은 보시는대로 276ms가 걸렸습니다. 전체에서 중간정도의 Runtime이 걸렸습니다. 시간을 줄이고 싶어서 다른 분들이 짠 코드를 봤는데, 너무 신선한 방식들이라서 가져와 봤습니다.

2️⃣ 번째 방법

이 방식이 현재 Runtime이 가장 빠르다라고 되어 있어서 봤는데, 너무 신선했습니다. 방식이 엄청 어려운 것은 아닌데, 이렇게도 풀 수 있었는데 싶었던 방식이었습니다.

제가 처음에 c언어를 배울 때 많이 사용하던 방식이었는데요. 바로 유니코드를 사용하는 방식입니다.

일단 Array를 만들고 26칸을 생성해줍니다. 소문자 알파벳의 갯수라고 생각하시면 됩니다. 그리고 각 칸에는 0으로 초기화를 해줘요.

우리는 'a'의 유니코드를 기본으로 해서 그에 맞춰서 각 character에 index를 부여할 겁니다. 예를 들어서 'c'가 들어온다면, 'c'는 유니코드로 99에 해당하기 때문에 'c' - 'a'를 하게 되면 2가 나오게 됩니다. counter[2]는 c가 들어가는 칸이 되고 우리가 생각했던 index에 맞춰 들어가는 걸 알 수 있죠?

각 character가 index에 맞춰서 들어가면 해당 index에 들어있는 숫자가 +1씩 증가하게 됩니다. 즉, 0이면 아무것도 안들어옴. 1이면 1개, 2면 2개가 들어온거죠.

그리고 두 번째 for문에서 counter의 값이 1이면 해당 index(i)를 return 합니다.

첫 번째와는 다르게 배열을 사용했기 때문에 이미 들어오는대로 정렬이 잘 되어 있어서 따로 sorted를 안해도 되고 Array를 이미 26개의 자리에 맞춰서 만들어둬서 훨씬 편합니다.

extension UnicodeScalar {
    var intValue: Int {
        return Int(value)
    }
}

func firstUniqChar(_ s: String) -> Int {
    var counter = Array(repeating: 0, count: 26)
    let a_unicode = UnicodeScalar("a").intValue

    for c in s.unicodeScalars {
        counter[c.intValue - a_unicode] += 1
    }

    var i = 0
    for c in s.unicodeScalars {
        if counter[c.intValue - a_unicode] == 1 {
            return i
        }

        i += 1
    }

    return -1
}

Runtime이 쏙 내려간 걸 알 수 있습니다.

3️⃣ 번째 방법

가장 Runtime이 빨랐어요.! 분명 이중 for문을 썼는데 제일 빨라서 놀랐습니다.

이번에는 Array와 Set를 사용했습니다.

이번 문제는 chars에 있는 문자를 하나씩 빼내서 자신의 index 뒤에 있는 모든 문자들과 하나씩 대조해보면서 푸는 문제였습니다.

만약에 같은 문자가 뒤에 있다면 그 문자는 skipChars라는 Set에다가 넣어두고 다음에 그 문자 차례가 왔을 때 where조건에 걸려서 그 문자는 다시 for문을 돌지 못하게 했습니다.

그리고 뒤에 자신과 같은 문자가 없다면 isUnique라는 Boolean타입을 true로 만들어서 해당 index를 return하게 해줬습니다.

func firstUniqChar(_ s: String) -> Int {
    let chars: [Character] = [Character](s)
    var skipChars: Set<Character> = []

    for i in 0 ..< chars.count where !skipChars.contains(chars[i]) {
        var isUnique: Bool = true

        for j in i + 1 ..< chars.count {
            guard isUnique else { break }
            if chars[i] == chars[j] {
                isUnique = false
                skipChars.insert(chars[i])
                break
            }
        }

        if isUnique { return i }
    }

    return -1
}

보시다시피 시간이 굉장히 빨랐습니다. 이중 for문인데도 불구하고 Runtime이 가장 빠르게 나왔어요!!

아마도 contains되는 애들을 바로바로 제외시키기도 했고, 또 for문을 돌려서 return하는 게 아니라 지금 상태에서 Unique하다면 바로 그 index를 return시키는 방식으로 해서 그런지 빠른게 아닌가 싶습니다.

Link of Problem

LEVEL : 🌕 🌕 🌕 🌑 🌑 (중)

Medium으로 넘어온 뒤에 풀어본 2번째 문제였습니다.

이 문제는 제목 그대로, Matrix를 0으로 설정하는 문제였습니다. Matrix속에 0이 있다면 그 0이 있는 자리와 같은 행, 열에 있는 수들을 모두 0으로 변경시키는 문제였습니다.

이번에 문제를 풀 때 노력해본 것이 있다면, 문제를 보고 코드로 바로 치기보다는 생각 먼저 해보기였습니다. 말은 쉽지만 문제를 보면 코드로 먼저 치기 마련이거든요. 이번엔 공책에 문제를 좀 정리하고 풀도록 했습니다.

꾸준히 습관으로 만들 생각입니다.

1️⃣ 번째 방법

처음 든 생각이 "한 번 for문을 돌면서 어느 지점에 0이 있는지 찾아내자" 였습니다.

일단 enumerated()를 써서 row에 있는 배열 뿐만 아니라 각 배열의 index, 그리고 배열 안에 있는 원소들의 column index를 빼왔어요. 그리고 해당 위치에 있는 숫자가 0이라면 그 row, column에 해당하는 index를 전에 만들어둔 Set에다가 넣어줬습니다.

Set를 사용한 이유는 Set이 중복을 제거해주기 때문입니다. 0이 같은 행,열에 있을 경우 계속해서 같은 숫자가 들어오게 되는데 이럴 경우에는 이미 0으로 만들어진 행,열을 또 0으로 만드는 의미없는 일들이 계속 일어날 거 같아서 Set으로 만들어 중복을 완전히 제거해줬습니다.

그리고 위의 for문에서 설정한 rows colunms에 따라서 for문을 돌리면서 행과 열에 0를 집어 넣어줬습니다.

func setZeroes(_ matrix: inout [[Int]]) {
    var rows = Set<Int>()
    var colunms = Set<Int>()

    for (index, row) in matrix.enumerated() {
        for (col, num) in row.enumerated() {
            if num == 0 {
                rows.insert(index)
                colunms.insert(col)
            }
        }
    }

    for i in rows {
        for j in 0..<matrix[0].count {
            matrix[i][j] = 0
        }
    }

    for i in colunms {
        for j in 0..<matrix.count {
            matrix[j][i] = 0
        }
    }
}

Runtime은 너무 나쁘지도 좋지도 않은 정도로 나왔습니다.

2️⃣ 번째 방법

두 번째 방식도 첫번째와 크게 다르지 않습니다. 하나 다른 게 있다면, 위처럼 행과 열을 적용해주는 코드를 2번에 나눠서 쓰지 않고 한 번에 썼어요.

insert해주는 코드는 거의 동일하고, insert에 맞춰서 새로운 0를 넣어주는 부분이 조금 달랐습니다.

이번에는 contains를 사용해서 이중 for문을 돌렸습니다. 해당 부분의 숫자가 0이 아니고, rows 또는 cols에 들어있는 행, 열이라면 그 부분을 0으로 만들어줬습니다.

이중 for문이 2번으로 줄었기 때문에 시간이 훨씬 줄었을거라고 생각했는데요.

func setZeroes(_ matrix: inout [[Int]]) {
    if matrix.count == 0 { return }

    var rows: Set<Int> = []
    var cols: Set<Int> = []

    for i in 0..<matrix.count {
        for j in 0..<matrix[i].count {
            if matrix[i][j] == 0 {
                rows.insert(i)
                cols.insert(j)
            }
        }
    }

    for i in 0..<matrix.count {
        for j in 0..<matrix[i].count {
            if matrix[i][j] != 0 && (rows.contains(i) || cols.contains(j)) {
                matrix[i][j] = 0
            }
        }
    }
 }

처음엔 오히려 늘었습니다..😂 역시 Leetcode의 Runtime은 오락가락이네요.. 그래도 두번째 돌렸을 때는 많이 떨어졌어요.

Link of Problem

LEVEL : 🌕 🌕 🌑 🌑 🌑 (하)

Easy Collection String의 두번째 문제인 Reverse Integer를 풀어봤습니다.

Reverse Interger문제도 저번 Reverse String만큼 쉬웠습니다. 말 그대로 Integer를 Reverse시키는 겁니다.

조금 걸리는 부분이 있었다면,

1. 음수도 들어올 수 있기때문에 reverse할 때 - 부호를 처리하는 점
2. 2의 31제곱 이상, -2의 31제곱 이하 그리고 0은 꼭 0를 return해야 한다는 점 이었습니다.

이 부분들만 고려하면서 코드를 짜면 쉽게 짤 수 있었습니다.

1️⃣ 번째 방법

저는 위에 있는 부분들을 처리하기 위해서 if문을 통해 두 가지 조건으로 나눴습니다. 첫 번째는 0보다 큰 수가 들어오는 부분, 두 번째는 0보다 작은 수가 들어오는 부분으로 했어요. 0은 처음에 들어왔을 때, guard를 통해서 처리했습니다.

x가 0보다 클 땐 일단 수를 reverse하고 Int로 변환합니다. 그리고 변환된 수가 2의 31제곱 이상이면 0를 return해주고 아니면 해당 수를 return 합니다.

x가 0보다 작을 땐 수에서 -를 제외하고 reverse를 시킨 후 Int로 변환합니다. 그리고 변환된 수에 -를 붙인 값이 -2의 31제곱 이하면 0를 return하고 아니면 해당 수를 return합니다.

func reverse(_ x: Int) -> Int {
    guard x != 0  else { return 0 }

    if x > 0 {
        let reverse = String("\(x)".reversed())

        if let reverse = Int(reverse) {
            guard reverse < Int(pow(2.0, 31)) else { return 0 }
            return reverse
        }
        return 0
    } else {
        let reverse = String("\(-x)".reversed())

        if let reverse = Int(reverse) {
            guard -reverse > Int(pow(-2.0, 31)) else { return 0 }
            return -reverse
        }
        return 0
    }
}

Runtime은 4ms정도 걸렸습니다.

2️⃣ 번째 방법

2번째 방법도 1번째 방법과 비슷한 형태로 짜여져 있습니다. 다른점이 있다면 첫번째는 if문을 사용해서 음수, 양수를 나눴다면 2번째 방법은 isNegative라는 Boolean값을 만들어서 음수일 때의 처리를 따로 했습니다.

그리고 reversed()라는 함수를 사용하지 않고 for문을 돌려서 character를 하나씩 받아서 처리를 해줬습니다.

func reverse(_ x: Int) -> Int {
        var stringNum = String(x)
        var newStr = ""
        var isNegative = false

        for char in stringNum {
            if char == "-" {
                isNegative = true
                continue
            }
            newStr = "\(char)" + newStr
        }

        if isNegative {
            newStr = "-" + newStr
        }

        guard let numToReturn = Int(newStr) else { return 0}
        if (numToReturn > 2147483647) || (numToReturn < -2147483648) { return 0}
        return numToReturn
}

요정도의 시간이 나오긴 하는데, 1번째 방법도 그렇고 Runtime이 계속 바뀌더라구요. 0~8ms를 왔다갔다 하는 거 같습니다.

Link of Problem

LEVEL : 🌕 🌕 🌕 🌑 🌑 (중)

Array에서 Easy Collection은 끝났기 때문에 Medium Collection으로 넘어왔습니다.!

역시나 어려웠고, 쉽게 풀리지 않았습니다.🥲 첫 문제부터 저는 1시간만에 Solution를 찾아 봤네요.. 열심히 해야겠습니다.

3Sum은 배열안에 있는 숫자들 중에 3개 숫자의 합이 0이 되는 조합을 찾아서 배열 형태로 배열에 넣는 문제였습니다.

처음에 문제를 풀었을 때, 되겠다 싶었는데. 나타날 다양한 케이스를 고려하지 않아서 각 케이스에서 Wrong이 뜰 때마다 보수공사를 했습니다.. 결론적으로 이 코드는 못 쓰겠다 싶어서 다른 방식들을 찾아봤고 결과적으로 좋은 코드를 찾을 수 있었습니다.

정렬하는 방식들을 정말 많이 공부해야겠어요...🥲

1️⃣ 번째 방법

해당 방식은 Wrong Answer만 나왔습니다.

문제를 보자마자 정렬을 시킨 다음, 앞 숫자부터 2개씩 묶어서 뒤에 숫자와 합이 0이 되는지 봐야지. 라고 생각했지만. 너무 많은 케이스를 고려 안했습니다..🥲

당연히 nums안에 있는 케이스가 3개 미만이라면 3개의 sum를 찾을 수 없기 때문에 빈 배열을 return했고, nums를 sorted한 값들이 들어있는 sortedNums의 가장 첫 번째값이 0보다 크다면 아무리 세 값을 더해도 0이 나올 일이 없다는 뜻이기에 빈 배열을 return해줬습니다.

그리고 아래 코드에서 볼 수 있듯이 두 값을 묶은 다음(0 이하인 두 값), 0 이상인 한 값과 더 해서 sum이 나오면 answers에다가 넣어줬습니다.

하지만 문제가 많더라구요.. 먼저 중복이 생기는 문제가 나와서 return할 때 Set으로 감싸주는 일을 했어요. 그 다음으로 생긴 문제가 양의 정수 두 개가 음의 정수 한 개와 더해졌을 때 0이 되는 케이스가 있다는 겁니다. 이 케이스를 다루려면 완전히 코드를 새로 짜는 게 낫다는 결론이 나서 다른 코드를 찾아봤습니다.

func threeSum(_ nums: [Int]) -> [[Int]] {
    guard nums.count >= 3 else { return [] }

    let sortedNums = nums.sorted()
    guard sortedNums[0] <= 0 else { return [] }

    var answers: [[Int]] = []
    for i in 1..<sortedNums.count where sortedNums[i-1] <= 0 {
        let sum = sortedNums[i] + sortedNums[i-1]

        if sum > 0 { continue }

        if i+1 > sortedNums.count-1 { break }

        for j in (i+1...sortedNums.count-1).reversed() where sortedNums[j] >= 0 {
            if sum + sortedNums[j] == 0 {
                answers.append([sortedNums[i-1], sortedNums[i], sortedNums[j]])
                break
            }
        }
    }

    return Array(Set(answers))
}

2️⃣ 번째 방법

결론적으로 답이 된 코드입니다.

일단 세팅하는 코드는 비슷합니다. 다른 점은 풀어가는 방식이죠! 왜 이 생각을 못했지 싶었습니다..

first current last 이 세가지 숫자를 둘 겁니다. first(i)는 맨 앞에서부터 오는 값, last(k)는 맨 뒤에서부터 오는 값, current(j)는 first와 last 사이 값을 찾을 겁니다.

first는 for문을 통해서 차례대로 받아올 것이고, current는 항상 first+1한 값에서 시작할 겁니다. last는 맨 뒤(count - 1)에서 시작하면 되겠죠?

중간 중간 sorted[i] == sorted[i-1], sorted[j] == sorted[j-1]인 경우를 넘겨서 중복이 생길 경우들도 없애줄 거예요.

그리고 current가 last보다 작을 때에만 first + current + last의 값을 구하고 그 값이 0이 맞다면 result에 넣을 겁니다. 만약에 sum보다 작다면, current(j)값을 위로 올려서 sum값을 올리겠죠. 반대로 sum보다 크다면, last(k)의 값을 내려서 sum값을 내릴겁니다.

해당 코드는 이러한 과정을 통해서 진행됩니다.

func threeSum(_ nums: [Int]) -> [[Int]] {
    guard nums.count >= 3 else { return [] }

    let sorted = nums.sorted()
    var result: [[Int]] = []
    for i in 0..<sorted.count {
        if i != 0, sorted[i] == sorted[i-1] { continue }

        var j = i + 1
        var k = sorted.count-1

        while j < k {
            let sum = sorted[i] + sorted[j] + sorted[k]
            if sum == 0 {
                result.append([sorted[i], sorted[j], sorted[k]])
                j += 1
                while j < k, sorted[j] == sorted[j-1] {
                    j += 1
                }
            } else if sum < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }

    return result
}

세 값을 나눠서 진행하기 때문에 위에 코드처럼 2개씩 묶기 때문에 나타나는 문제도 해결되고, 심지어 중복도 나타날 일이 없습니다. first, last, current를 따로 나눠서 배열 문제를 해결해본 적이 처음이라서 바로 생각하지 못한 거 같습니다. 이제 알게됐으니 열심히 사용해보려구요. 너무 좋네요👍

Link of Problem

LEVEL : 🌕 🌑 🌑 🌑 🌑 (최하)

Easy Collection String의 첫번째 문제인 Reverse String를 풀어봤습니다. 벌써 Array가 끝났네요.

Reverse String문제는 매우 쉬웠습니다. 말 그대로 String를 Reverse시키는 겁니다.

제가 첫번째로 풀었던 코드는 고작 한 줄 밖에 되지않아요..

그럼 Reverse String를 코드와 함께 풀어보겠습니다.

1️⃣ 번째 방법

아마 알고리즘을 해보신 분들이라면 제목을 보자마자 "이걸 써야겠다" 싶을 거예요. 제목 그대로 Reverse를 쓰는 겁니다.

func reverseString(_ s: inout [Character]) {
    s.reverse()
}

끝났습니다. 이게 다입니다. reverse()라는 함수는 주어진 배열을 완전 반대로 알아서 뒤집어 줍니다.

Runtime은 적당히 나온 거 같아요.

2️⃣ 번째 방법

2번째 방식은 가장 Runtime이 빨랐던 코드를 가져왔습니다.

배열의 대칭되는 부분에 있는 숫자들을 바꿔주는 코드였어요. 어차피 대칭되는 위치에 있는 숫자들을 사용할 생각이어서 middle를 놓았습니다. for문으로 전체 숫자를 보지 않아도 되기 때문에 middle를 두는 편이 더 효과적입니다.

그리고 temp를 둬서 두 숫자의 위치를 바꿔줬습니다. 전형적인 swap 로직이었어요.

func reverseString(_ s: inout [Character]) {
    let middle = Int(s.count / 2)
    for index in 0..<middle {
        let temp = s[index]
        s[index] = s[s.count - index - 1]
        s[s.count - index - 1] = temp
    }
}

분명히 더 빠른 코드였는데, 제가 돌리니깐 1번 방식보다 느리게 나왔습니다. Leetcode가 돌리면서 계속 차이가 있는 거 같아요..!

Link of Problem

LEVEL : 🌕 🌕 🌑 🌑 🌑 (하)

Easy Collection의 열한번째 문제이자 Array 마지막 문제인 Rotate image를 풀어봤습니다.

Rotate image는 주어진 이차원배열 형식의 값들을 90도 회전시키는 문제였습니다.

문제 자체에 대한 접근은 쉬웠는데, 문제에서 조건으로 내걸었던 "다른 배열로 옮기지 말고 현재 배열에서 변경해라" 라는 말이 문제를 어떻게 풀어야 할 지 생각을 하게 만들었습니다.

같이 코드를 보면서 설명 진행해볼게요.

1️⃣ 번째 방법

일단 문제가 한 번에 풀렸습니다. 저번 스토쿠 문제가 저한테는 어려웠기 때문에 이번 문제도 당연 어려울 거라는 생각때문인지 고민을 많이 했습니다. 하지만 간단하게 이중 for문으로 풀이를 완료했어요. 다행입니다..🥲

문제 자체에서는 다른 배열로 옮기지 말라고 했지만, 저는 다른 배열로 옮기는 수 밖에는 생각이 안들어서 일단 배열 하나를 만들고 matrix에 있는 값들을 옮겨줬어요.

그리고 해당 배열에서 row를 하나씩 빼내오면서 row안의 값을 enumerated()를 사용해서 index와 함께 하나씩 빼줬습니다. 그러고나서 matrix의 맨 뒤 column부터 하나씩 채워갔어요.

어떤 방식을 사용했냐면 matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]라고 했을 때, 90도로 돌린다면 matrix = [[7, 4, 1], [8, 5, 2], [9, 6, 3]]이 들어옵니다. 잘 생각해보면 각 배열의 맨 첫 번째 숫자들이 첫 번째 배열에 모이고, 두 번째 숫자들은 두 번째 배열, 세 번째 숫자들은 세 번째 배열에 모이는 걸 볼 수 있습니다. 그리고 순서는 뒤부터 들어오는 걸 볼 수 있어요.

해당 방식을 이용해서 첫 번째 배열 숫자들은 맨 마지막 열에 순서대로 배치하고, 중간 배열 숫자들은 중간 열에 순서대로 배치, 마지막 배열 숫자들은 첫 번째 열에 순서대로 배치했습니다.

func rotate(_ matrix: inout [[Int]]) {
    guard matrix.count != 1 else { return }
    let temp = matrix
    var column = matrix.count - 1

    for row in temp {
        for (index, i) in row.enumerated() {
            matrix[index][column] = i
        }
        column -= 1
    }
}

Runtime은 8ms로 괜찮게 나왔습니다!! 하지만 8ms보다 빠른 Runtime을 가진 코드가 있더라구요.

2️⃣ 번째 방법

이번 코드는 다른 배열을 추가하지 않고 해당 배열 안에서만 숫자 변경을 진행했습니다. 처음에 이런 방식을 생각하긴 했지만 어떻게 내가 원하는 숫자들끼리 변경하지 싶어서 시도해보지 않은 방식이었는데, 이렇게 하면 될 걸 싶었습니다.

일단 해당 코드는 두번의 이중 for문을 거쳐요. 그럼에도 빠른 이유는 matrix가 제일 커도 n이 20이라는 점과 배열을 하나만 사용하기 때문이 아닐까 싶습니다.

첫 번째 이중 for문은 각각 자기 자리와 상반되는 위치에 있는 숫자를 서로 바꿔줍니다. 처음에 이 코드를 보고 굳이 이렇게 왜 바꾸지 싶었습니다. 이해하고 보니, 해당 코드를 거치고 난 후에 우리가 원하는 숫자들끼리 한 배열에 묶여있게 된다는 걸 알게 됐습니다..!

두 번째 이중 for문은 이제 같은 배열에 있는 숫자들끼리 자리를 바꿔줍니다. 아마 위에 for문을 거치고 난 배열은 우리가 원하는 배열과는 완전히 반대로 생겼을 거예요. reversed()를 해주고 싶게 생겼습니다. 그 반대로 뒤집는 걸 두 번째 이중 for문이 해줄겁니다.

func rotate(_ matrix: inout [[Int]]) {
    let n = matrix.count

    for i in 0..<n {
        for j in i..<n {
            let temp  = matrix[i][j]
            matrix[i][j] = matrix[j][i]
            matrix[j][i] = temp
        }
    }

    for i in 0..<n {
        for j in 0..<n/2 {
            let temp  = matrix[i][j]
            matrix[i][j] = matrix[i][n - 1 - j]
            matrix[i][n - 1 - j] = temp
        }
    }
}

분명, 첫 번째 문제 풀 때 해당 코드보다 빠르다고 되어 있었는데 제가 돌려보니 더 느리게 나왔습니다. 8ms나 12ms나 큰 차이는 아니니깐요.!

Link of Problem

LEVEL : 🌕 🌕 🌕 🌑 🌑 (중)

Easy Collection의 열번째 문제인 Valid Sudoku를 풀어봤습니다.

Valid Sudoku는 주어진 이차원 배열 속 스도쿠 숫자들을 통해 해당 스도쿠가 문제가 없는지 확인하는 문제였습니다.

기본적인 스도쿠 규칙대로 같은 행, 열에 같은 숫자가 있으면 안되고, 같은 3*3 칸 속에도 같은 숫자가 있으면 안됩니다. 주어진 이차원 배열이 해당 규칙을 따르는지 확인하면 됩니다.

저는 행, 열을 확인하는 로직은 바로 생각이 났지만 3*3 규칙에 해당하는 로직이 바로 떠오르지 않아서 고민 끝에 Solution 찬스를 썼습니다.

전에 C++로 알고리즘을 짰을 때, 썼던 dfs 방식이 생각나긴 했는데 그 비슷한 방식으로 하던거 같아요!

Solution 코드들을 같이 봅시다.

1️⃣ 번째 방법

첫번째 방식은 row, colum, box(3*3짜리 칸)를 확인하는 Set를 따로 세 개씩두고 확인하는 방식이었습니다.

해당 방식은 저번에 했던 Two Sum때와 동일하게 enumerated()를 사용했는데요.

첫 for문에서는 characterRow 자체를 빼오고 두번째 for문에서는 그 row안에 있는 character들을 하나씩 빼오는 방식이었습니다. 그리고 enumerated()를 사용해서 해당 character의 index를 함께 가져와서 Set으로 만들어져있는 row, columns, boxes에 넣어줬습니다.

만약, 해당 character가 contains = true에 해당한다면 조건에 부합하지 않기 때문에 결론적으로 false를 return하고 아니면 true를 return하도록 해줬습니다.

row, column, box별로 index를 둬서 character가 있는 자리를 표시하도록 했습니다. /3를 해준 이유는 각 칸별로 index를 잡기 위함이에요. 행, 열 총 3*3칸이 한 box를 이루고 있기 때문이죠.

func isValidSudoku(_ board: [[Character]]) -> Bool {
    let size = board.count
    var columns = (0..<size).map { _ in Set<Character>(minimumCapacity: size) }
    var boxes = (0..<size).map { _ in Set<Character>(minimumCapacity: size) }

    for (rowIndex, characterRow) in board.enumerated() {
        var row = Set<Character>()
        for (columnIndex, character) in characterRow.enumerated() {

            if character == "." {
                continue
            }

            let rowBoxIndex = Int(rowIndex / 3)
            let columnBoxIndex = Int(columnIndex / 3)
            let boxIndex = columnBoxIndex + (rowBoxIndex * (size/3))

            if row.contains(character) {
                return false
            }
            row.insert(character)

            let column = columns[columnIndex]
            if column.contains(character) {
                return false
            }
            columns[columnIndex].insert(character)

            let box = boxes[boxIndex]
            if box.contains(character) {
                return false
            }
            boxes[boxIndex].insert(character)
        }
    }
    return true
}

2️⃣ 번째 방법

두 번째 방법도 첫 번째 방법과 비슷합니다. 조금 다른 부분은 String으로 넣어줬고, row, column, grid에 각각 직접 정한 String값을 넣었어요.

하지만 전체적인 방식은 아주 비슷합니다. contains되어있는지 확인하고 아니라면 insert 맞다면 false를 return합니다.

위에서는 enumerated()를 사용한 것과는 다르게 0부터 9까지 이중 for문을 돌렸어요. 어차피 스도쿠 판은 9*9 크기로 한정되어 있기 때문에 그렇습니다.

위에 보다 좀 더 이해하기 쉽고 생각하기도 쉬웠던 로직 같습니다.

func isValidSudoku(_ board: [[Character]]) -> Bool {
    var setSudoku = Set<String>()

    for i in 0..<9 {
        for j in 0..<9 {
            if board[i][j] != "." {
                let value = board[i][j]
                let row = "row:\(i):\(value)"
                let column = "column:\(j):\(value)"
                let grid = "row:\(i / 3):\(j / 3):\(value)"

                if setSudoku.contains(row) || setSudoku.contains(column) || setSudoku.contains(grid) {
                    return false
                } else {
                    setSudoku.insert(row)
                    setSudoku.insert(column)
                    setSudoku.insert(grid)
                }
            }
        }
    }
    return true
}

저는 당연히 있는 숫자들끼리 비교하려고 했는데, 다른 Set를 만들 생각을 왜 못했는지 모르겠네요 🥲 더 노력해야겠습니다.

Link of Problem

LEVEL : 🌕 🌕 🌑 🌑 🌑 (하)

Easy Collection의 아홉번째 문제인 Two Sum를 풀어봤습니다.

Two Sum 문제는 배열 안에 있는 두 원소의 합이 들어오는 Target과 같다면 그 두 값의 index를 배열로 return해주는 문제였습니다.

처음 생각한 방식이 시간 초과가 날 것 같아서 걱정이었는데, 생각할 수 있는 가장 기본적인 로직임에도 불구하고 시간 초과는 발생하지 않았습니다!

해당 코드말고도 생각하지 못했던 방식으로 풀어낸 방법들이 있어서 해당 코드들도 들고와봤습니다.

코드를 보면서 설명드릴게요.

1️⃣ 번째 방법

제일 기본적이고 바로 생각할 수 있는 방식이었습니다.

첫번째 원소부터 시작해서 마지막 원소까지 맞는 짝을 샅샅히 뒤지는 방식입니다. 찾아내기 위해서 이중 for문을 사용했구요. target값과 index에 해당하는 값의 차가 j에 해당하는 값과 같다면 두 수의 합이 target이라는 것이기에 [index, j]를 return해줬습니다.

기본적이기도 하고 이중for문을 사용했기 때문에 당연히 시간 초과 에러가 날 줄 알았는데, 나지 않았어요!!

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
    for index in nums.indices {
        for j in index+1..<nums.count {
            if target - nums[index] == nums[j] {
                return [index, j]
            }
        }
    }

    return []
}

하지만 예상했던대로 Runtime이 아주 길었습니다..

2️⃣ 번째 방법

문제를 맞추자마자 가장 빠른 Runtime를 가진 답변을 찾아봤더니, 이거였습니다.

전체적으로 빠른 Runtime를 가진 답변들이 다 Dictionary를 사용했더라구요. 또 Dictionary를 응용하지 못해서 아쉬웠습니다.😫

해당 방식의 풀이는 이러합니다.

일단 nums에 있는 숫자들을 불러와서 해당 숫자가 target-num index에 해당하는 값이 있다면 그 index와 현재 index를 return하는 방식입니다. 만약에 해당하는 숫자가 없다면 Dictionary에 index와 함께 넣어주는거죠.

예를 들어, nums = [2, 7, 11, 15]이고 target = 9라면 첫번째 턴에 numDictionary[9-2]값을 찾아보겠죠? 하지만 아무것도 없기 때문에 numDictionary[2] = 0를 넣어줄겁니다. 두번째 턴에 numDictionary[9-7]값을 찾아보겠죠? 아까 넣어준 2 인덱스 값이 0이기 때문에 match = 0일 거고, 결론적으로 [0, 1]를 return할 겁니다.

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
    var numDictionary = [Int: Int]()
    var index = 0
    for num in nums {
        if let match = numDictionary[target - num] {
            return [match, index]
        } else {
            numDictionary[num] = index
        }
        index += 1
    }
    return []
}

Runtime 속도도 굉장히 빠릅니다.👍

3️⃣ 번째 방법

3번째 방법은 2번째 방법과 비슷하면서도 조금 다릅니다.

동일하게 Dictionary를 쓰는 건 맞지만 for문을 돌리는 방식이 달라요. 해당 방식은 nums.enumerated()를 사용했습니다. 저 방식을 사용하면 (index, num)에 해당하는 두 값이 나와요. 예를 들어서 "Swift"라는 문자열을 .enumerated()하게 된다면 [ 1: "S", 2: "w", 3: "i", 4: "f", 5: "t" ] 요렇게 된다는거죠.

저러한 방식을 사용해서 nums = [2, 7, 11, 15]에서 index와 num값을 한 번에 가져오는 겁니다.

안에서 비교하는 방식은 위와 같은데 조금 다른건 처음 비교할 때 target에서 num를 뺀 값이 아닌 그 값 자체의 index를 찾는 방식입니다. 그리고 값이 없을 때 Dictionary에 저장하는 방식도 target - num한 값에 값으로 현재의 index를 넣습니다.

위에 코드를 이해한다면 3번째 방식도 쉽게 이해할 수 있을 것이라고 생각이 듭니다.

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
    var complement = [Int: Int]()
    for (index, num) in nums.enumerated() {
        if let prevIndex = complement[num] {
            return [prevIndex, index]
        } else {
            complement[target - num] = index
        }
    }
    return []
}

항상 방식이 다양하게 사용할 수 있지만, 계속 배열을 쓰게 되는 거 같아요. Dictionary나 요런 다양한 자료구조들이 조금 익숙해지면 자주 사용하게 되겠죠?😂

Link of Problem

LEVEL : 🌕 🌕 🌑 🌑 🌑 (하)

Easy Collection의 여덟번째 문제인 Move Zeroes를 풀어봤습니다.

문제 제목 그대로, 0인 값들을 뒤쪽으로 옮기는 문제였습니다.

이번 문제에서는 들어오는 nums의 값이 inout으로 표시가 되어서 직접 사용할 수 있었는데요, 항상 inout으로 되어 있는 문제는 새로운 배열을 만드는 것보다 그 자체에서 값을 바꿨을 때 효율이 컸어서 이번에도 그렇게 해보려고 노력했습니다.

코드를 보면서 설명드리겠습니다.

1️⃣ 번째 방법

이번에는 1번째 방식으로 한 번에 문제를 풀었습니다.

저는 일단 위에서 말한 것처럼 지금 주어진 배열에서 문제를 바로 풀기 위해서 nums에서 0을 찾으면 해당 0를 지우고 맨 뒤로 0를 넣는 방식으로 코드를 짰습니다.

그렇게 되면 index가 0에서 바로 1로 계속해서 +1되는 방식이 아닌 해당 수가 0이 아니라면 +1되는 방식으로 진행되어야 합니다. 그러다보니 index를 조건문에 넣게 되면 1개라도 0이 있을 경우 조건을 영영 못 맞출 수도 있습니다.

그래서 따로 cnt라는 값을 둬서 한 턴마다 +1되도록 했습니다. 이렇게 했을 경우 원소의 개수에 맞게 조건문을 돌릴 수 있어서 좋았습니다.

func moveZeroes(_ nums: inout [Int]) {
    guard nums.count > 1 else { return }

    var index = 0
    var cnt = 0

    while cnt < nums.count {
        if nums[index] == 0 {
            nums.remove(at: index)
            nums.append(0)
        } else {
            index += 1
        }
        cnt += 1
    }
}

Runtime은 32ms정도로 좋았습니다.

Link of Problem

LEVEL : 🌕 🌕 🌑 🌑 🌑 (하)

Easy Collection의 일곱번째 문제인 Plus One를 풀어봤습니다.

처음에 문제를 잘못 파악했을 때 쉬운 문제인 줄 알았는데, 생각보다 머리를 써야하는 문제였습니다.

Array의 맨 마지막 숫자에 +1를 했을 때 값을 Array로 출력하는 문제였는데요. 문제는 +1했을 때 해당값이 10이 되면 해당 부분을 0으로 바꿔주고 앞 부분들에 해당 carry가 +1되어야 하는 문제였어서 그런 부분들이 조금 까다로웠습니다.

코드를 보면서 설명드리겠습니다.

1️⃣ 번째 방법

잘못 이해한 방식입니다.

문제를 보자마자 "뭐야, 맨 마지막 배열 원소에 +1 하면 되잖아?" 라고 생각해서 푼 방식입니다. 실제로 맨 뒤 숫자가 9 미만이라면 carry가 생길 일이 없기 때문에 해당 방식이 맞지만, 9라면 해당 방식이 완전히 잘못 됐기 때문에 2번 방식부터는 9를 생각하면서 풀었습니다.

func plusOne(_ digits: [Int]) -> [Int] {
        var num = digits

        num[digits.count-1] += 1

        return num
}

2️⃣ 번째 방법

실패한 방식입니다.

+1를 어떻게 해주면 좋을까 하다가. 배열에 있는 원소들을 자리에 맞게 10의 거듭제곱을 곱해서 숫자로 만든 다음, 1를 더한 값을 다시 배열에 넣으면 되겠다! 싶었습니다.

그렇게 하면 따로 1를 더하는 로직을 짜지 않아도 숫자니깐 자연스럽게 더해지겠죠?

func plusOne(_ digits: [Int]) -> [Int] {
    var num: [Int] = []
    var sum = 0

    for i in 0..<digits.count {
        sum += digits[i] * Int(pow(10, Double(digits.count - (i + 1))))
    }

    sum += 1

    for n in "\(sum)" {
        num.append(Int(String(n))!)
    }

    return num
}

하지만 문제가 생겼습니다. 가장 긴 배열의 길이가 100이기 때문에 100의 100 거듭제곱까지 나타나게 되는데, 해당 길이가 Int가 충족시킬 수 있는 길이를 넘어서 Fatal Error가 발생합니다.

혹시나 싶어서 UInt로도 진행해봤는데요. 똑같은 Fatal Error가 발생했습니다..🥲

3️⃣ 번째 방법

그렇다면 어떻게 +1를 해줄까 싶었습니다.

문득 1번째 방법에서 말했듯 9가 아니라면 다 carry를 생각해줄 필요가 없는데, 제가 그냥 배열에서 +1 해도 되는 걸 숫자로 푼 다음에 다시 배열로 만드는 헛수고를 하고 있다는 걸 깨달았습니다.

그럼 일단, +1를 하고서 맨 뒤가 10이라면 carry 문제를 해결하자 라는 결론이 나왔습니다.

맨 뒤 숫자부터 보면서 해당 숫자가 9보다 크다면 10으로 나눈 나머지 값을 값으로 가지고 해당 수의 앞에 있는 수에 +1를 더해줬습니다.

하지만 해당 수가 맨 앞에 있는 숫자라면 어떡하지? 라는 생각이 들더라구요. 그럼 그 앞에 1를 넣어주자 라는 결론이 나왔습니다. insert를 사용해서 원하는 위치에 1를 넣도록 코드를 짰습니다.

func plusOne(_ digits: [Int]) -> [Int] {
    var num = digits

    num[digits.count - 1] += 1

    for i in num.indices.reversed() {
        if num[i] > 9 {
            num[i] = num[i] % 10

            if i == 0 {
                num.insert(1, at: 0)
            } else {
                num[i - 1] += 1
            }
        }
    }

    return num
}

Runtime도 4ms밖에 안걸렸습니다.

매일 코드를 짜면 감이 좀 잡힐 것 같았는데, 아직은 Swift에서 사용할 수 있는 자료구조를 많이 몰라서 그런지 쉽게 앞으로 나아가지질 않네요🥲 더 갈고 닦아야겠습니다.

Link of Problem

LEVEL : 🌕 🌕 🌑 🌑 🌑 (하)

Easy Collection의 여섯번째 문제인 Intersection of Two Arrays II를 풀어봤습니다.

이번 문제는 제목과 동일하게 두개의 배열에 있는 원소들의 교집합을 찾는 문제였습니다.

두 Array에 있는 공통적인 원소들을 찾는 것이라서 간단해보일 수 있지만 들어오는 Array에 따라 다양한 조건을 충족시켜줘야 했기 때문에 조금 복잡한 감이 있었습니다.

이번 코드들은 다양한 시도 끝에 답이 나왔기 때문에 답을 보고 싶으신 분들은 4️⃣ 번째 방법부터 보시면 되겠습니다.

1️⃣ 번째 방법

실패한 방식입니다.

처음에 교집합이라는 단어를 보자마자 Set를 써야겠구나. 생각했습니다. Set에는 intersection이라는 직접 교집합을 찾아주는 함수가 있습니다.

이걸 이용해서 교집합을 찾으면 되겠구나. 라고 생각했는데, 아니었습니다.

예를 들어, nums1 = [1, 2, 2, 1] num2 = [1, 1] 이라고 한다면 답은 [1, 1]이 나와야 합니다. 하지만Set은 자체적으로 중복을 제거해버리기 때문에 답으로 나오는 값은 [1]뿐인거죠.

func intersect(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
    var setNums1 = Set<Int>()

    for i in nums1 {
        setNums1.insert(i)
    }

    setNums1 = setNums1.intersection(nums2)

    return Array(setNums1)
}

2️⃣ 번째 방법

또 다른 실패 방식

그럼 중복이 생길 수 있게 해야겠다. 생각했습니다.

일단 두 배열 중 더 짧은 코드로 for문을 돌리면서 긴 배열에 있는 숫자가 contain되어 있으면 result라는 배열에 넣는거죠. 하지만 해당 코드도 문제가 있습니다. 반대로 중복이 생겨버렸어요.

예를 들어, nums1 = [1, 2, 3] nums2 = [1, 1] 라고 했을 때 답으로 [1]이 나와야 합니다. 하지만 답으로 [1, 1]이 나와요. 왜냐면 짧은 배열을 기준으로 하기 때문에 1이 nums1에 있는지 2번 확인하기 때문이죠. 그렇다고 해서 긴 배열로 for문을 돌리면 해결되는 문제도 아닙니다.

func intersect(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
    var result: [Int] = []

    if nums1.count > nums2.count {
        for num in nums2 {
            if nums1.contains(num) {
                result.append(num)
            }
        }
    } else {
        for num in nums1 {
            if nums2.contains(num) {
                result.append(num)
            }
        }
    }

    return result
}

3️⃣ 번째 방법

또또 다른 실패 방식

그래서 이번에는 중복을 확인한 숫자는 사라지도록 remove함수를 사용했습니다. 전에 있던 코드에서 remove만 추가했는데, 위에 있는 예시가 해결되었습니다.

하지만, submit를 했더니 또 다른 문제가 생겼습니다. 32번째 case에서 Wrong이 떴더라구요.. 분명 중복을 제거한다고 했는데 제대로 안되는지 문제가 계속 생겼습니다..😂

func intersect(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
    var result: [Int] = []
    var arr: [Int] = []

    if nums1.count > nums2.count {
        arr = nums1
        for num in nums2 {
            if arr.contains(num) {
                result.append(num)
                arr.remove(at: arr.firstIndex(of: num) ?? 0)
            }
        }
    } else {
        arr = nums2
        for num in nums1 {
            if nums2.contains(num) {
                result.append(num)
                arr.remove(at: arr.firstIndex(of: num) ?? 0)
            }
        }
    }

    return result
}

4️⃣ 번째 방법

드디어 성공했습니다.

하지만 위에 실패한 코드들과 약간 다릅니다. 위에 있는 코드에서는 num1, num2의 count별로 case를 나눴다면 해당 코드는 case를 나누지 않고 진행했어요. case 나눈 거 때문에 위 코드에 문제가 생긴거라면 너무 맘이 아프네요🥲

해당 코드도 위와 동일하게 contains된 부분들을 삭제해줬어요.

func intersect(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
    var result: [Int] = []
    var arr: [Int] = []

    arr = nums1
    for num in nums2 {
        if arr.contains(num) {
            result.append(num)
            arr.remove(at: arr.firstIndex(of: num)!)
        }
    }

    return result
}

하지만, Runtime이 많이 걸리더라구요. 544ms나 걸렸습니다.. 그래서 Runtime를 짧게 만들기 위한 방식을 찾아봤습니다.

5️⃣ 번째 방법

Runtime이 Best인 방식이었습니다. 그리고 Dictionary를 사용한 점이 굉장히 인상깊었던 방식입니다.

코드를 설명하자면, 먼저 Dictionary인 dic를 하나 만들어주고 해당 Dictionary에 key값과 value값을 모두 Int로 받는다고 명시해줍니다.

그리고 먼저 num1에 있는 값들을 하나씩 세줍니다. dic[num, default: 0] += 1 이 부분이 뭔가 싶을 수도 있는데요. 예를 들자면, num1 = [1, 2, 3, 1, 2]라고 할 때에 저 for문을 돌린다고 하면, dic안의 값은 [ 1 : 2, 2 : 2, 3 : 1 ]이 됩니다. for문에서 들어온 num값이 key값으로 들어가는데 그 전에 들어왔던 적이 없으면 default: 0이 아니라면 전 value에서 +1된 값이 value로 들어옵니다.

완성된 Dictionary를 기준으로해서 nums2에 있는 값들과 비교해줍니다. 안에 nums2에 있는 숫자가 있으면 result에 넣어주고 value값을 -1 해줍니다.

func intersect(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
    var dic: [Int: Int] = [:]

    for num in nums1 {
        dic[num, default: 0] += 1
    }

    var result = [Int]()

    for num in nums2 {
        if let freq = dic[num], freq > 0 {
            result.append(num)
            dic[num] = freq - 1
        }
    }

    return result
}

Dictionary를 이런식으로 쓸 수 있다는게 참신했습니다. 당연히 num들을 직접 비교하는 방식을 생각했는데, num가 몇개 있는지 센 후에 진행하는 방식은 처음이었습니다.

아직까지 Swift에서 제공해주는 자료구조들을 다 알진 못해서 문제를 풀 때마다 새로운 자료구조를 배워가는 기분입니다.

Swift 알고리즘 얼른 정복할 겁니다.

Link of Problem

LEVEL : 🌕 🌕 🌑 🌑 🌑 (하)

Easy Collection의 다섯번째 문제인 Single Number를 풀어봤습니다.

이번 문제는 중복없이 혼자만 존재하는 숫자를 찾는 문제였습니다.

앞에 문제들이 중복 제거나 중복 확인을 하는게 대부분이여서 다른 문제들의 방식을 사용할 수도 있었어요. 하지만 되게 특이한 방식도 있더라구요, 소개해드리고 싶어서 가져왔습니다.

먼저 기본적인 방법부터 코드를 보여드리면서 설명하겠습니다.

1️⃣ 번째 방법

전에 중복이 있는지 찾아내는 로직을 조금 수정했습니다.

nums에 있는 숫자가 1개라면 바로 그 숫자를 return하고, 그 이상이라면 먼저 sorted를 한 후에 양 옆의 숫자들이 같은 수인지 확인하는 방식으로 로직을 짰습니다.

해당 index의 수와 index+1의 수가 같다면 index+2해주는 식으로 해서 이미 확인한 수를 다시 확인하지 않도록 했습니다. 그리고 양 옆에 숫자가 같지 않다면 그 수가 바로 혼자 존재하는 수이기 때문에 해당 숫자를 return하도록 했습니다.

하지만 nums 맨 끝에 있는 수가 혼자 존재하는 수이고, nums에 들어있는 수가 홀수라면 while조건에 따라서 맨 끝에 있는 수를 확인하지 못하게 됩니다. 하지만 그 수가 혼자 존재한다는 건 명백하기 때문에 while문을 원만하게 통과했다면 return를 num에 있는 마지막 숫자로 했습니다.

func singleNumber(_ nums: [Int]) -> Int {
    guard nums.count > 1 else { return nums[0] }

    let num = nums.sorted()
    var index = 0

    while index < nums.count-1  {
        if num[index] == num[index+1]{
            index += 2
        } else {
            return num[index]
        }
    }

    return num[nums.count-1]
}

해당 방식이 runtime은 느렸지만 memory측면에서는 좋았습니다.

2️⃣ 번째 방법

해당 방식은 memory측면에서는 좋지 않지만 중복을 문제에 자주 등장하는 Set를 이용한 문제였습니다.

일단 Set를 하나 만들어두고 nums에 있는 숫자를 Set이 가지고 있다면 remove하고 가지고 있지 않다면 insert하는 방식으로 로직을 구현했습니다.

전 코드보다 이해하기도 쉽고 runtime도 전보다 빠르게 나왔습니다.

contains된 것만 지우기 때문에 결국 혼자있는 숫자는 나갈 수가 없는 형태인거죠. 그 점을 이용해서 for문을 돌리고 배열에 있는 첫번째 원소를 return 했습니다.

func singleNumber(_ nums: [Int]) -> Int {
    var tempNums = Set<Int>()
    for value in nums {
        if tempNums.contains(value) {
            tempNums.remove(value)
        } else {
            tempNums.insert(value)
        }
    }
    return tempNums.first!
}

3️⃣ 번째 방법

runtime이 가장 좋은 방법이며, 생각지도 못한 방법이었습니다.

일단 코드부터 보여드리겠습니다.

func singleNumber(_ nums: [Int]) -> Int {
    var result = 0
    for num in nums {
        result ^= num
    }
    return result
}

코드가 매우 짧고, 간결합니다. 하지만 저는 처음부터 이해하진 못했습니다. ^= 이 친구가 무슨 뜻인지 도통 몰랐거든요.

^= 는 뭘까?

XOR(^)를 아시나요? 우리가 아는 OR(||)은 비교하는 두 개의 값 중 하나만 True여도 True를 return합니다. XOR은 OR과는 다르게 두 개의 값이 다른 값을 가지고 있어야 True를 return합니다.

한마디로 1(true) ^ 0(false) = 1(true) 인거죠.

^=은 result = result ^ num를 뜻합니다. 두 값의 XOR값이 result로 들어올 겁니다.

^=를 써서 어떻게 문제를 푼다는거죠?

저도 처음에 ^=와 중복이 무슨 상관이라고 저 방식을 사용한다는 거지. 우연히 해보니깐 된건가? 이렇게 생각했습니다.

하지만 XOR의 의미를 이해한다면 충분히 저 방식으로 풀어낼 수 있더라구요.

예시를 들어보겠습니다. nums = [1, 2, 3, 2, 3] 이라고 하겠습니다.

처음에 1이 들어오면 0 ^ 1 => 0000 ^ 0001 = 0001(1) 이 됩니다. 2가 들어오면 1 ^ 2 => 0001 ^ 0010 = 0011(3) 이 됩니다. 3이 들어오면 3 ^ 3 => 0011 ^ 0011 = 0000(0) 이 됩니다. 2가 들어오면 0 ^ 2 => 0000 ^ 0010 = 0010(2) 이 됩니다. 3이 들어오면 2 ^ 3 => 0010 ^ 0011 = 0001(1) 이 됩니다.

결국 정답인 1이 나옵니다.

XOR은 같은 자리에 중복으로 나오는 값을 0으로 만들고 서로 다른 값을 1로 만듭니다. 그렇기 때문에 두 개의 숫자가 중복으로 나오면 0010(2) ^ 0010(2) = 0000(0) 이렇게 0이 될 수 밖에 없는거죠. 결국 중복으로 나타나 자신의 숫자를 지울 값이 없는 숫자만이 살아남게 됩니다.

그 원리를 사용해서 문제를 푼 거구요.

XOR, NOR, XAND 등등 이런걸로 한 번도 뭘 해보겠다는 생각이 없었는데, 이렇게 간단하게 풀기에 좋다니.. 너무 신기하더라구요. 정말 공부해야할 게 많고 가야할 길이 멀다는 걸 또 느낍니다.

Link of Problem

LEVEL : 🌕 🌑 🌑 🌑 🌑 (최하)

Easy Collection의 네번째 문제인 Contains Duplicate를 풀어봤습니다.

첫번째 문제에서는 중복을 제거했다면 이번 문제는 중복이 있는지 확인하는 문제였습니다.

전에 한 번 중복을 찾아내는 문제를 풀었기 때문에 그와 비슷한 방식으로 문제를 풀어나갔습니다.

1️⃣ 번째 방법

첫번째 방법은 시간 초과가 난 로직입니다.

저번에도 시간 초과가 났었는데, 이번 문제에서도 시간 초과가 발생했습니다.

가장 기본적인 이중 for문으로 짰었기에, 짤 때부터 이건 시간 초과가 발생하겠구나 싶은 로직이었습니다.

문제가 생긴 이유 1<= element 갯수 <= 10^5 만큼의 배열크기가 들어올 수 있다고 했기 때문에 숫자가 커짐에 따라 시간 초과 문제가 발생한 것 같습니다. 이미 문제를 풀면서도 예상했던 부분이었습니다.

func containsDuplicate(_ nums: [Int]) -> Bool {
    guard nums.count > 1 else { return false }

    for i in 0..<nums.count-1 {
        for j in i+1..<nums.count {
            if nums[i] == nums[j]{
                return true
            }
        }
    }
    return false
}

2️⃣ 번째 방법

서로 멀리 떨어진 숫자들을 어떻게 대조해서 중복이 있는 걸 찾을까 고민을 하다가, 멀리 떨어져있다면 붙이면 되겠다 라는 생각이 들었습니다.

일단 정렬을 하고 나서 양 옆에 같은 숫자가 있는지 확인하는거죠.

func containsDuplicate(_ nums: [Int]) -> Bool {
    guard nums.count > 1 else { return false }

    let num = nums.sorted()

    for index in 1..<nums.count {
        if num[index] == num[index-1]{
            return true
        }
    }
    return false
}

nums가 전 문제들처럼 inout으로 써진게 아니여서 따로 num이라는 배열을 사용했습니다.

그리고 num에 있는 element들 양옆에 같은 숫자가 있으면 true를 바로 return하도록 로직을 짰습니다.

2번째 방식의 Runtime은 중간정도의 속도가 나오더군요.

3️⃣ 번째 방법

3번째 방법은 보자마자 왜 나는 이런 생각을 못했을까 싶었던 방식이었습니다.

바로 중복을 싫어하는 Set를 써서 Set에 들어간 nums의 갯수와 그냥 nums의 갯수를 비교하는거죠. 만약 중복이 있다면 Set에 들어간 것과 그냥 nums에 있는 원소의 갯수가 차이날 것입니다.

func containsDuplicate(_ nums: [Int]) -> Bool {
    nums.count != Set(nums).count
}

고작 한 줄 입니다. 왜 이 생각을 못했을까요? 항상 중복이 나오면 Set를 쓰자라고 생각을 했는데, 이번 문제에서는 왜 그러지 못했는지..🥲

알고리즘 더 열심히 해야겠습니다.

Link of Problem

LEVEL : 🌕 🌕 🌑 🌑 🌑 (하)

Easy Collection의 세번째 문제인 Rotate Array를 풀어봤습니다.

제목 그대로 배열을 Rotate하는 로직 짜기가 문제였습니다.

전 문제들처럼 쉽게 풀 거라고 예상했지만 시간 초과가 났고, 시간복잡도가 O(n)의 효율을 낼 수 있는 코드를 생각하다보니 자연스레 코드 자체가 좀 복잡해졌습니다.

코드를 보여드리면서 설명하겠습니다.

1️⃣ 번째 방법

첫번째 방법은 시간 초과가 난 로직입니다.

그렇기 때문에 바로 정답을 보고 싶으시다면 2번째 방법부터 보시는 걸 추천드립니다.

시간 초과가 난 이유를 저도 정확히 알 것 같습니다.

문제가 생긴 이유 일단 머릿속으로 정리했을 때, 맨 뒤에 있는 element가 앞으로 오고 앞에 있는 것들이 차례대로 뒷줄로 밀려나야한다고 생각이 들어서 이중 for문을 사용했습니다. 해당 문제는 전제로 1<= element 갯수 <= 10^5 만큼의 배열크기가 들어올 수 있다고 했기 때문에 숫자가 커짐에 따라 시간 초과 문제가 발생한 것 같습니다.

func rotate(_ nums: inout [Int], _ k: Int) {
    if nums.count > 1 {
        for _ in 0..<k {
            let num = nums[nums.count-1]

            for j in (0...nums.count-2).reversed() {
                nums[j+1] = nums[j]
            }
            nums[0] = num
        }
    }
}

2️⃣ 번째 방법

이중 for문이 안된다면 O(n)의 효율이 나도록 단일 for문만 돌려야 된다는 생각이 들었습니다.

하지만 단일 for문을 사용해서 어떻게 이중 for문과 같은 효율을 내지 싶더라구요. 그래서 공간 복잡도를 늘리는 대신, 배열을 하나 더 만들기로 했습니다.

해당 배열에 nums에 있는 숫자들을 k부터 차곡차곡 넣다가 다시 0~k-1까지 넣는 방식으로 구현했습니다.

nums = [1, 2, 3, 4, 5, 6, 7] k = 3 라고 한다면 sub = [#, #, #, 1, 2, 3, 4] 를 먼저 넣고 sub = [5, 6, 7, 1, 2, 3, 4] 를 다음에 넣어주는거죠.

func rotate(_ nums: inout [Int], _ k: Int) {
    var sub = [Int](repeating: 0, count: nums.count)
    for i in 0..<nums.count {
        sub[(i + k) % nums.count] = nums[i]
    }

    for i in 0..<nums.count {
        nums[i] = sub[i]
    }
}

일단, sub라는 배열은 배열의 크기를 초기화해줘야 합니다. 알고리즘하면서 [Int](repeatint:0, count: nums.count) 이렇게 처음 써봅니다.. 그냥 var sub: [Int] = [ ] 이렇게 사용하면 out of range 오류가 뜨더라구요. 빈 배열이기 때문에 그렇겠죠.

그리고 안에서 (i + k) % nums.count를 사용해서 위의 방식을 구현해줬습니다. 해당 식으로 계산하게 되면 k = 3일 때는 3부터 sub라는 배열에 숫자가 차게되고 이후에 (i + k)값이 nums.count값 이상으로 가게되어 0부터 다시 숫자가 시작되기 때문에 해당 방식을 구현할 수 있게 됩니다.

2번째 방식은 Runtime이 아주 빨랐습니다.👍

3️⃣ 번째 방법

3번째 방법은 대표 답안으로 작성되어 있던 걸 Swift로 구현한 방식입니다.

대표 답안 자체가 Leetcode에서는 Java, 아니면 Python으로 되어 있기 때문에 방식이 다소 Java 코드 같을 수 있습니다.

하지만 효율은 2번째 방식보다 5ms정도 더 좋았습니다.

func rotate(_ nums: inout [Int], _ k: Int) {
    let l = k % nums.count
    var count = 0

    for start in 0..<nums.count where count < nums.count {
        var current = start
        var prev = nums[start]

        repeat {
            let next = (current + l) % nums.count
            let temp = nums[next]
            nums[next] = prev
            prev = temp
            current = next
            count += 1
        } while (start != current)
    }
}

해당 방식은 코드로 보기에도 이해하기가 복잡합니다.

간단하게 설명하자면

이런 방식입니다. 저는 2번째 방식이 훨씬 짜기 쉽다고 생각이 들어서 3번째 방식은 참고해서 짜는걸로 만족했습니다.

요건 뭐지?

저는 알고리즘으로 처음 배우는 문법이 많았습니다. 너무 뷰 짜는데만 Swift를 쓴 거 같다는 생각이 들더라구요.. 그 문법 중 하나가 repeat-while이었습니다.

repeat-while은 do-while과 동일한 기능을 하는 친구입니다.

do-while과 사용 방식은 동일하기 때문에 설명은 더 안하겠습니다.!

repeat-while를 더 알고 싶다면

4️⃣ 번째 방법

제가 생각하기에 가장 간단하고 편한 방식인 거 같습니다.

func rotate(_ nums: inout [Int], _ k: Int) {
    if k < 1 || nums.isEmpty {
        return
    }
    let k = k % nums.count
    nums = Array(nums[nums.count - k..<nums.count] + nums[0..<nums.count-k])
}

Runtime도 가장 좋고 코드도 쉽습니다. Swift의 Array는 Subscript를 사용해서 배열의 값을 범위만큼 가져올 수 있습니다. 이 점을 이용해서 코드를 짰습니다.

앞부분엔 k+1 인덱스부터 끝까지 가져온 elements를 넣고 뒷부분엔 앞부터 k까지의 elements들을 넣어서 앞에서 귀찮게 for문돌렸던 걸 쉽게 해결했습니다.

Link of Problem

LEVEL : 🌕 🌑 🌑 🌑 🌑 (최하)

Easy Collection의 두번째 문제인 Best Time to Buy and Sell Stock II를 풀어봤습니다.

저번에 첫 문제를 한 번 풀어봐서 그런지, 비슷한 방식으로 풀어가면 되는거라서 크게 어려움은 없었습니다.

또한 첫 시도에서 좋은 Runtime를 얻고 best example과도 크게 차이가 없어서 저번보다 시도 횟수가 많이 줄었습니다.

일단 제가 썼던 코드를 한 번 보여드리겠습니다.

1️⃣ 번째 방법

이번 문제는 전에 산 물건이 후에 팔았을 때 가장 큰 이득을 얻었다고 할 때, 얼마의 이득을 얻는가에 대한 문제였습니다.

즉, 후에 이득이 나지 않는다면 팔지 않아도 된다는 겁니다.

그래서 저는 현재(index)가 전(index-1)보다 더 큰 수를 가지고 있는 경우에 profit에다가 값을 더 해줬습니다.

func maxProfit(_ prices: [Int]) -> Int {
    var profit = 0

    for index in 1..<prices.count {
        if prices[index-1] < prices[index] {
            profit += prices[index] - prices[index-1]
        }
    }

    return profit
}

이렇게 코드를 짰더니, 결과는 Success 하지만, Runtime도 좋았습니다.

2️⃣ 번째 방법(best example)

한 번에 완료하고나서 앞에 더 좋은 example들을 살펴보았습니다.

제가 사용한 방법과 비슷한 맥락으로 코드가 대부분 짜여져있었는데요. 조금 특이한 방식을 봤습니다.

"where"

저는 SQL이후로 where를 오랜만에 보는 것 같습니다. swift에도 where이 있더라구요..

func maxProfit(_ prices: [Int]) -> Int {
    var profit = 0

    for index in 1..<prices.count where prices[index-1] < prices[index] {
        profit += prices[index] - prices[index-1]
    }

    return profit
}

if문 대신에 where를 써서 for문 조건에다가 where조건을 달아줬더라구요. 정말 신기했습니다.

이렇게 쓸 수 있을뿐만 아니라 값 바인딩, 타입 캐스팅, 익스텐션에서도 사용할 수 있었습니다. 나중에 한 번 써보려구요. # where reference

Link of Problem

LEVEL : 🌕 🌑 🌑 🌑 🌑 (최하)

Easy Collection의 첫번째 문제인 Remove Duplicates from Sorted Array를 풀어봤습니다.

영어로 문제가 써져있다보니 문제를 해석하는 것부터가 어렵더라구요. 하지만 문제 제목에서 유추할 수 있듯이 Sorted된 Array에 있는 중복된 숫자를 제거하는 문제였습니다.

처음 풀었을 때도 고작 코드 3-4줄로 Solved를 했고 나중에 Runtime를 줄이기 위해서 다른 방식을 찾았을 때도 10줄이 안넘었던 거 같네요.

그럼 제가 문제를 해결해갔던 방향을 한 번 설명드리겠습니다.

1️⃣ 번째 방법

Duplicate라는 단어를 보자마자 생각났던게 Set이었습니다. 아시다시피 Set에 넣은 element들은 모두 중복이 제거된 상태로 저장이 됩니다.

그렇기 때문에 처음에 들어온 배열을 Set를 사용해서 중복을 제거해주고, 그 후에 .sorted()를 하는 방식을 선택했습니다.

func removeDuplicates(_ nums: inout [Int]) -> Int {
    let numset = Set(nums)
    nums = numset.sorted()
    return nums.count
}

이렇게 코드를 짰더니, 결과는 Success 하지만, Runtime이 길더라구요.

그래서 시간을 줄이기 위한 여정이 시작되었습니다.

2️⃣ 번째 방법

혹시나 Set를 쓴 게 많은 시간을 소요한 건 아닐까 싶어서 이번엔 Set없이 for문으로 돌렸습니다.

func removeDuplicates(_ nums: inout [Int]) -> Int {
    var numset: [Int] = []
    for n in nums {
        if !numset.contains(n) {
            numset += [n]
        }
    }
    nums = numset
    return nums.count
}

하지만, 전보다 더 긴 시간이 소요됐어요... 340ms..🥲

3️⃣ 번째 방법

Set도 for문도 아니면 뭘까. 엄청 생각을 하다가 뭔가 제가 신경쓰지 않고 있던 게 있다는 걸 깨달았습니다.

그건 바로 "numset"

그냥 nums에서 처리하면 됐던 걸 numset까지 만들면서 nums와 numset으로 값을 왔다갔다 옮기고 있더라구요..

그래서 nums에서만 처리할 수 있도록 코드를 짰습니다.

func removeDuplicates(_ nums: inout [Int]) -> Int {
    guard nums.count > 1 else { return nums.count }
    var cnt = 0

    for index in 1..<nums.count {
        if nums[index] == nums[index-1]{
            cnt += 1
        } else {
            nums[index-cnt]=nums[index]
        }
    }
    return nums.count - cnt
}

결과는 56ms ! Set를 사용했을 때랑 30ms정도밖에 차이는 안나지만 쉬운 문제였기 때문에 시간에 집착을 좀 해봤습니다.

🙃 inout

이번 문제를 풀면서 처음 본 inout이라는 문법.

함수의 파라미터를 함수 내부에서 변경하고 함수가 종료된 후에도 변경한 값이 지속되도록 하려면 변수의 주소값을 넘겨 직접 접근할 수 있도록 도와주는 inout 키워드 사용

그렇다고 하네요. 파라미터를 함수 내부에서도 변경할 수 있도록 써주는 키워드라고 합니다. 전에 배웠던 C, C++에 있던 포인터가 생각나는 키워드입니다.

위에 써있는 것처럼 주소값을 넘겨줘야 하기 때문에 C, C++과 동일하게 &를 사용해서 인수를 명시해줘야 합니다.

func start() {
    var ber = [1, 2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 7]
    let num: Int = removeDuplicates4(&ber)
}

이렇게 말이죠.

알고리즘 공부하면서 배워가는 것도 많은 것 같습니다. # inout reference

코어데이터 누구세요? Apple Developer Documentation - Core Data 🌈

Core Data는 데이터베이스가 아닙니다. 데이터베이스의 역할을 하는 Persistence(SQLite)가 Core Data 기능 중 하나 일 뿐이지요. Core Data는 넓은 의미로 앱의 모델 계층이며, 객체 그래프를 관리하는 Framework입니다.

코데 어떻게 생겼어요?

코데는 이렇게 RelationShip를 지정할 수 있어요.

지금은 1:多 로 만들어진 모습입니다.

CRUD 코드들 보여주세요!

// create
@discardableResult
func insertContent(content: Content) -> Bool {
        let entity = NSEntityDescription.entity(forEntityName: "Contents", in: self.context)

        if let entity = entity {
            let managedObject = NSManagedObject(entity: entity, insertInto: self.context)

            managedObject.setValue(content.title, forKey: "title")
            managedObject.setValue(content.content, forKey: "content")
            managedObject.setValue(content.date, forKey: "date")

            do {
                try self.context.save()
                return true
            } catch {
                print(error.localizedDescription)
                return false
            }
        } else {
            return false
        }
}

// read 
func fetch() -> [NSManagedObject] {
        let appDelegate = UIApplication.shared.delegate as! AppDelegate
        let context = appDelegate.persistentContainer.viewContext
        let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Contents")

        // sort
        let sort = NSSortDescriptor(key: "date", ascending: false)
        fetchRequest.sortDescriptors = [sort]

        let result = try! context.fetch(fetchRequest)
        return result
}

// update
func updateContent(title: String, content: String) {
        guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
        let managedContext = appDelegate.persistentContainer.viewContext
        let fetchRequest: NSFetchRequest<NSFetchRequestResult> = NSFetchRequest.init(entityName: "Contents")
        fetchRequest.predicate = NSPredicate(format: "title = %@", contentTitle)

        do {
            let test = try managedContext.fetch(fetchRequest)
            let objectUpdate = test[0] as! NSManagedObject

            objectUpdate.setValue(title, forKey: "title")
            objectUpdate.setValue(content, forKey: "content")
            objectUpdate.setValue(Date(), forKey: "date")

            do {
                try managedContext.save()
            } catch {
                print(error)
            }
        } catch { print(error) }
}

// delete
func deleteContent(title: String) {
        guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
        let managedContext = appDelegate.persistentContainer.viewContext
        let fetchRequest: NSFetchRequest<NSFetchRequestResult> = NSFetchRequest.init(entityName: "Contents")
        fetchRequest.predicate = NSPredicate(format: "title = %@", title)

        do {
            let test = try managedContext.fetch(fetchRequest)
            let objectToDelete = test[0] as! NSManagedObject

            managedContext.delete(objectToDelete)
            do {
                try managedContext.save()
            } catch {
                print(error)
            }
        } catch {
            print(error)
        }
}

CRUD 코드들 입니다.

CRUD를 하는 방법은 쉬워요! 하지만 그 이상으로 가는 건 어려운 것 같습니다. 지금 제 목표는 RelationShip를 사용해서 데이터를 사용하는 겁니다. 그 때까지 도-약해보겠습니다.🚀🚀

너무 구현해보고 싶어서 다양한 도전끝에 길을 찾았습니다. 공유해볼게요!

...Λ＿Λ （ㆍωㆍ)つ━☆。 ⊂　　 ノ 　　　.뾰 し-Ｊ　　　°。로 ´¨) ..　.· ´¸.·롱´¨) ¸.·*¨) (¸.·´ (????¸.'

저는 저 안에

[backButton]
[bottomLineView]
[CollectionView]

이렇게 전체적인 뷰를 구성해줬어요.

이렇게 구성되어진 뷰를 기반으로 만들었기 때문에, 저랑 다르게 레이아웃을 잡았을 경우에는 다른 방법을 찾는 걸 추천드립니다!

저는 일단 CollectionView의 기반인 ScrollView가 Scroll되는걸 감지해서

저 bottomLineView가 움직이게 해줬어요.

func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) { }

이 함수를 사용해서 ScrollView의 Dragging이 끝날때쯤에 현재 CollectionView의 index를 감지해서 해당 인덱스에 맞게 LineView가 움직이도록 했어요.

func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
                let cellWidthIncludingSpacing = UIScreen.main.bounds.size.width

                // targetContentOff을 이용하여 x좌표가 얼마나 이동했는지 확인 
                // 이동한 x좌표 값과 item의 크기를 비교하여 몇 페이징이 될 것인지 값 설정
        var offset = targetContentOffset.pointee
        let index = (offset.x + scrollView.contentInset.left) / cellWidthIncludingSpacing
        var roundedIndex = round(index)


                // scrollView, targetContentOffset의 좌표 값으로 스크롤 방향을 알 수 있다. 
                // index를 반올림하여 사용하면 item의 절반 사이즈만큼 스크롤을 해야 페이징이 된다. 
                // 스크로로 방향을 체크하여 올림,내림을 사용하면 좀 더 자연스러운 페이징 효과를 낼 수 있다.
        if scrollView.contentOffset.x > targetContentOffset.pointee.x {
            roundedIndex = floor(index)
        } else if scrollView.contentOffset.x < targetContentOffset.pointee.x {
            roundedIndex = ceil(index)
        } else {
            roundedIndex = round(index)
        }

                // 기존에는 스크롤한 값에 대해 페이징되는 인덱스 값을 구하여, 인덱스 크기만큼 페이징 처리를 했습니다.
                // 업데이트 된 코드에서는 페이징되는 인덱스 크기를 1로 수정하여 하나씩만 페이징 되도록 처리했습니다.
        if currentIndex > roundedIndex {
            currentIndex -= 1
            roundedIndex = currentIndex
            moveNegativeDirection()
        } else if currentIndex < roundedIndex {
            currentIndex += 1
            roundedIndex = currentIndex
            movePositiveDirection()
        }

                // 위 코드를 통해 페이징 될 좌표값을 targetContentOffset에 대입하면 된다.
        offset = CGPoint(x: roundedIndex * cellWidthIncludingSpacing - scrollView.contentInset.left, y: -scrollView.contentInset.top)
        targetContentOffset.pointee = offset
}

// + 방향으로 움직임
// 전체 width사이즈에서 현재 가지고 있는 text의 갯수만큼 나눈걸 index만큼 곱해주면
// index가 클 수록 멀게 이동한다
func movePositiveDirection() {
        UIView.animate(withDuration: 0.3, animations: {
            self.lineView.transform = CGAffineTransform(translationX: UIScreen.main.bounds.size.width/self.textCount * self.currentIndex, y: 0)
        })
}

// - 방향으로 움직임
// 전체 width사이즈에서 현재 인덱스를 빼준다
// index가 작아질수록 원래 자리로 돌아온다.
func moveNegativeDirection() {
        UIView.animate(withDuration: 0.3, animations: {
            self.lineView.transform = CGAffineTransform(translationX: UIScreen.main.bounds.size.width - UIScreen.main.bounds.size.width/self.textCount * (self.textCount - self.currentIndex), y: 0)
        })
}

복잡하죠..?

• cellWidthIncludingSpacing cellWidthIncludingSpacing를 스크린의 width로 지정했습니다. 나중에 cell 하나 하나의 크기를 알아야지 전체 스크롤해서 현재 index가 몇인지 알 수 있기 때문이지요.

• offset 현재 target이 되는 content의 좌표를 나타내고 있어요.

• index 현재 offset.x 좌표와 scrollView의 왼쪽 inset를 더한 다음에 셀 하나의 크기로 나눠서 현재 index로 넣어줬어요.

• roundedIndex roundedIndex를 통해서 계산한 index를 반올림했습니다. 뒤에 소수점이 생기는데 만약 소수점이 0.5 이상이면 위로 올리고 나머지는 그 밑으로 계산했어요.

누르면 +에서 x로 빙글 돌아가요!

저 밑에 버튼은 누르면 빙글빙글 돌아가네요. 그래서 구현해봤습니다. 저는 일단 저 친구를 기본적으로 90도만큼 이미 돌아간 상태로 만들어뒀어요. 지금 .gif에서 보시다시피

버튼을 누른다 → + 표시에서 x로 움직인다 → 버튼을 다시 누른다 → x 표시에서 +로 움직인다

이런 루틴으로 진행되는 걸 알 수 있어요.

일단은 저 친구는 처음 뷰에 들어오면 -90도 돌아가 있지만,

// 왼쪽으로 90도 돌아가게 해주는 코드
transform = CGAffineTransform(rotationAngle: -(.pi/4))

이 코드를 통해서 원래 모습으로 돌려줄 겁니다.

UIView.animate(withDuration: 0.3, animations: {
     self.transform = .identity
})

하지만 UIView.animate가 내 생각대로 안된다고 느낄겁니다.

왜냐면 내가 뷰를 키자마자 0.3만에 쇽샥 돌아가버려서 우리는 이미 빙글 돌아버린 x 표시만 볼 수 있습니다...

그래서 어떻게 해줬는가?

DispatchQueue을 모셨습니다.

DispatchQueue.main.asyncAfter(deadline: .now() + 0.05, execute: {
   UIView.animate(withDuration: 0.3, animations: {
        self.transform = .identity
   })
})

DispatchQueue는 뷰가 켜지고 나서 0.05 후에 저 animate를 불러주기 때문에 우리는 돌아가는 x 표시를 볼 수 있게 됩니다.🌈

다시 원래대로 돌아가면서 dismiss시키는건요?

아마 animate와 dismiss를 함께 시키면 animate가 구동되는걸 보지도 못한채 차갑게 dismiss되는 뷰를 볼 수 있습니다.

UIView.animate(withDuration: 0.3, animations: {
       self.exitButton.transform = CGAffineTransform(rotationAngle: -(.pi/4))
})
DispatchQueue.main.asyncAfter(deadline: .now() + 0.15, execute: {
       self.dismiss(animated: true, completion: nil)
})

그렇기 때문에 일단 animate를 보여주고 0.15뒤에 dismiss될 수 있도록 DispatchQueue을 불러주시면 될 것 같습니다.