[문제 링크] (https://school.programmers.co.kr/learn/courses/30/lessons/142086)

풀이

import Foundation

func solution(_ s:String) -> [Int] {
    var lastIndex: [Character : Int] = [:]
    var result = Array(repeating: -1, count: s.count)

    for (i, c) in s.enumerated() {
        result[i] = lastIndex[c] == nil ? -1 : i - lastIndex[c]!
        lastIndex[c] = i
    }

    return result
}

설명

• 딕셔너리로 각 문자의 마지막 인덱스를 저장

• result = Array(repeating: -1, count: s.count): 문자열의 개수만큼 -1 값으로 배열 생성

• enumerated(): 문자열의 (인덱스, 문자) 튜플을 반환. (i, c) 튜플로 for문에 활용

• lastIndex[c]가 nil이면 해당 문자는 처음 나온 문자이므로 -1 저장, 아니라면 현재 인덱스 - 가장 최근에 나왔던 인덱스

💡 딕셔너리의 반환값이 nil인 경우? Swift 딕셔너리에서 섭스크립트([key])로 접근하면 해당 키가 존재하지 않을 수 있기에 항상 Optional Type을 반환한다.

var dict = ["apple": 5, "banana": 3]
let apple = dict["apple"]    // Optional(5)

처음에는 이차원 배열로 해결하려고 했는데, 동일한 문자에 대해 값을 수정해야 해서 딕셔너리가 더 직관적이라고 판단했다. 다른 사람의 풀이에 비교해봐도 내 코드가 효율적이라고 느껴서 오늘은 다른 사람의 풀이 스킵! 👍

[문제 링크] (https://school.programmers.co.kr/learn/courses/30/lessons/181902)

풀이: 이중 forEach문 순회

import Foundation

func solution(_ my_string:String) -> [Int] {
    var result = Array(repeating: 0, count: 52)
    var alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    alpha += alpha.lowercased

    my_string.forEach { str in
        alpha.forEach {
            if str == $0 {
                result[Array(alpha).firstIndex(of: $0)!] += 1
            }
        }
    }

    return result
}

설명

var result = Array(repeating: 0, count: 52)

• 배열 선언과 동시에 초기화
• 52 길이의 배열 생성, 초기값은 0

result[Array(alpha).firstIndex(of: $0)!] += 1

• Array.firstIndex(of: Element): 반환값은 Int? 이므로 강제언래핑

다른 사람의 풀이

import Foundation

func solution(_ my_string:String) -> [Int] {
    var result = Array(repeating: 0, count: 52)

    my_string.forEach {
        result[Int($0.asciiValue!) - ($0.isUppercase ? 65 : 71)] += 1
    }

    return result
}

설명

asciiValue

let a: Character = "A"
if let ascii = a.asciiValue {
    print(ascii)  // 출력: 65
}

• Character 타입에서 제공하는 속성으로, 문자의 ASCII 코드값을 반환한다.
• UInt8?(옵셔널 UInt8) 타입이다. → Int와 사용 시 형변환 필요
• ASCII 문자에 대해서만 값을 반환하고, ASCII가 아닌 문자(예: 이모지, 한글 등)에 대해서는 nil을 반환한다.

💡 주요 아스키 코드를 알아두자.

• 대문자 A-Z: 65-90
• 소문자 a-z: 97-122
• 숫자 0-9: 48-57
• 공백: 32

isUppercase

let a: Character = "A"
print(a.isUppercase)  // 출력: true

• Character 타입에서 제공하며 문자의 대소문자 여부를 확인한다.

이중 forEach문 코드를 작성하면서도 이게 맞나, 긴가민가했는데 문자를 아스키코드로 바꿔주는 함수가 있다니! 갓위프트..👍 시간복잡도가 훨씬 축약됐다.

배열 선언과 동시에 초기화하는 코드도 많이 사용할 것 같으니 외워두기.

[문제 링크] (https://school.programmers.co.kr/learn/courses/30/lessons/181912)

풀이 1: 배열 인덱스

import Foundation

func solution(_ intStrs:[String], _ k:Int, _ s:Int, _ l:Int) -> [Int] {
    return intStrs.compactMap {
        Int(String(Array($0)[s...s+l-1]))
    }.filter { $0 > k }
}

설명

• String을 Array로 변환하면 각 요소는 Character 타입이 된다.

• Character ↔️ Int 형변환은 불가 → Character 요소를 String 타입으로 변환 후, Int로 변환

• map을 사용하면 [Int?] 타입이 반환되기에 강제언래핑 대신 compactMap 사용

💡 map VS compactMap map: 옵셔널 타입 결과를 그대로 유지 compactMap: nil 값은 제거하여 결과는 항상 non-optional 값

다른 사람의 풀이: prefix / suffix

func solution(_ intStrs: [String], _ k: Int, _ s: Int, _ l: Int) -> [Int] {
    return intStrs.map { Int($0.prefix(s + l).suffix(l))! }.filter { $0 > k }
}

설명

prefix와 suffix 작동 방식

1. prefix(n) 함수:

   • 문자열의 시작부터 지정된 개수(n)만큼의 문자를 포함하는 부분 문자열을 반환한다.
   • 예: "Hello".prefix(2)는 "He"를 반환한다.

2. suffix(n) 함수:

   • 문자열의 끝에서부터 지정된 개수(n)만큼의 문자를 포함하는 부분 문자열을 반환한다.
   • 예: "Hello".suffix(2)는 "lo"를 반환한다.

코드 실행 과정

• $0.prefix(s + l): 문자열의 처음부터 s + l개의 문자를 가져온다. → 필요없는 뒷 문자열 버리기

• .suffix(l): 그 결과에서 마지막 l개의 문자를 가져온다. → 필요없는 앞 문자열 버리기

• 결합하면, 인덱스 s부터 시작하여 길이 l만큼의 부분 문자열을 얻게 된다.

이전 포스팅에서 문자열 인덱스를 처리하려면 배열로 만든 후 배열의 인덱스를 사용하면 편하다고 작성했다. 오늘은 다른 사람의 코드를 보며 그 방법만 있는게 아니구나, prefix / suffix를 이용하면 번거로운 형변환 작업을 줄일 수 있구나 깨달았다. 까다로운 swift 문자열을 상대할 무기를 하나 더 얻은 기분이다.👊

문제 링크

풀이 1: for문

import Foundation

func solution(_ arr:[Int], _ queries:[[Int]]) -> [Int] {
    var result = arr

    for query in queries {
        let (s, e, k) = (query[0], query[1], query[2])

        for idx in s...e {
            result[idx] = idx % k == 0 ? result[idx] + 1 : result[idx]
        }
    }

    return result
}

고민

• for문을 사용해 풀기는 했지만, filter나 map 등의 함수를 이용해 더 간단하게 풀 수 있을까? → filter를 사용해 k의 배수인 arr[i] 값을 찾아내더라도, 그 값에 +1을 어떻게 하지?

다른 사람의 풀이

import Foundation

func solution(_ arr:[Int], _ queries:[[Int]]) -> [Int] {
    return queries.reduce(into: arr) { arr, query in
        (query[0]...query[1]).filter { $0 % query[2] == 0 }.forEach { arr[$0] += 1 }
    }
}

설명

1. reduce(into: arr) 함수의 역할

queries.reduce(into: arr) { arr, query in ... }

• reduce(into:): 초기값(arr)을 시작으로 컬렉션의 각 요소에 대해 누적 작업을 수행
• into: arr: 초기값으로 arr 배열의 복사본을 사용하고, 이를 직접 수정함
• 첫 번째 파라미터 arr: 현재까지의 누적 결과 배열 (mutable)
• 두 번째 파라미터 query: 현재 처리 중인 쿼리 정보

💡 reduce 함수를 축약형으로 사용하지 못하는 이유

reduce 함수 축약형은 주로 다음과 같은 경우에 사용한다.

1. 연산이 단일 연산자(+, * 등)로 표현 가능
2. 복잡한 조건문이나 다른 함수 호출이 없음
3. 누적값과 요소 모두 동일한 방식으로 처리됨

   reduce(into:)는 일반 reduce와 달리 다음과 같은 특성이 있다.

4. 누적값이 mutable로 처리됨 (직접 수정 가능)
5. 각 단계에서 반환값 필요 없음
6. 내부에서 컬렉션 조작이 자주 이루어짐 → 복잡한 작업의 경우 reduce(into:) 사용

2. 범위 생성 및 필터링

(query[0]...query[1]).filter { $0 % query[2] == 0 }

• query[0]...query[1]: s부터 e까지의 인덱스 범위를 생성
• .filter { $0 % query[2] == 0 }: 범위 내에서 k(query[2])의 배수인 인덱스만 선택

3. 선택된 인덱스의 배열 요소 수정

.forEach { arr[$0] += 1 }

• forEach: 선택된 각 인덱스에 대해 작업 수행
• 직접 원본 배열(참조로 전달된)을 수정함

→ 첫 풀이에서의 고민 해결!

💡 forEach 함수의 특징

• 반환 값이 없음: forEach는 Void를 반환한다. 즉, 결과를 모으거나 변환된 컬렉션을 반환하지 않는다.
• 원본 변경 없음: 원본 컬렉션을 변경하지 않는다.
• 순서 보장: 배열과 같은 순서가 있는 컬렉션에서는 요소를 순서대로 처리한다.
• break/continue 사용 불가
• return의 동작: 클로저 내에서 return을 사용하면 현재 요소의 처리만 종료하고 다음 요소로 진행한다 (전체 반복 종료 안 됨).

forEach 함수를 새롭게 알았다. method chaining을 통해 더 간결한 코드를 사용할 수 있을 것 같다.

reduce 함수는 축약형으로만 사용해오다 보니, 기본형을 사용할 생각은 못했다. 복잡한 처리가 필요한 경우에도 사용할 수 있구나 깨달았다.

[문제 링크] (https://school.programmers.co.kr/learn/courses/30/lessons/181928)

풀이 1: 반복문

import Foundation

func solution(_ num_list:[Int]) -> Int {
    var oddArr = num_list.filter { $0 % 2 == 1 }
    var evenArr = num_list.filter { $0 % 2 == 0 }
    var sumOfOdd = 0
    var sumOfEven = 0

    var square = Double(oddArr.count - 1)
    for n in oddArr {
        sumOfOdd += Int(Double(n) * pow(Double(10), square))
        square -= 1
    }

    square = Double(evenArr.count - 1)
    for n in evenArr {
        sumOfEven += Int(Double(n) * pow(Double(10), square))
        square -= 1
    }

    return sumOfOdd + sumOfEven
}

설명

• filter를 사용해 홀수와 짝수를 별도의 배열로 분리

• 10의 제곱을 사용해 각 배열의 숫자들을 자릿수에 맞게 변환

• pow() 함수의 각 파라미터와 반환 타입은 Double 혹은 Float만 가능하므로 형변환 진행

  💡 각 배열 값(n)에도 명시적 형변환이 필요한 이유? Swift는 강한 타입(strongly typed) 언어로, 다른 타입 간의 자동 형변환을 허용하지 않는다.

다른 사람의 코드

import Foundation

func solution(_ num_list:[Int]) -> Int {
    let even = Int(num_list.filter { $0 % 2 == 0 }.map { String($0) }.joined())!
    let odd = Int(num_list.filter { $0 % 2 != 0 }.map { String($0) }.joined())!
    return even + odd
}

설명

• .filter { $0 % 2 == 0 }: num_list에서 짝수만 필터링 → 배열 반환

• .map { String($0) }: 각 숫자를 문자열로 변환 → 배열 반환

• .joined(): 모든 문자열 이어붙이기. joined(separator: String = "") 형식이지만 separator 생략 가능

• Int(...)!에서 강제 언래핑: 형변환이 실패할 가능성이 있는 경우 Swift는 안전을 위해 옵셔널을 반환한다.

  💡 옵셔널 언래핑 두 가지 방법. ! vs ?? !: 강제 언래핑(Force Unwrapping) 값이 확실히 존재할 때만 사용한다. 옵셔널이 nil일 때 강제 언래핑하면 런타임 오류가 발생한다.

  
  `??`: Nil 병합 연산자 안전하게 옵셔널을 처리할 수 있는 방법이다. 왼쪽 피연산자가 `nil`이 아니면 그 값을 사용, `nil`이면 오른쪽 기본값을 사용한다.
  → `??` 언래핑이 안전하지만, 문제의 조건에 num_list 배열의 요소는 항상 정수이기에 `!` 언래핑을 사용했다.

filter 함수를 통해 홀수, 짝수 배열을 나누는 것까지는 생각했는데 Int 배열을 String으로 바꿔 문자열로 붙이는 생각을 못했다. 어쩐지 내 코드가 C언어스럽더라니... 다음엔 문자열로 변환 기억하기.

문제 링크

풀이 1: 오답

import Foundation

func solution(_ a:Int, _ b:Int, _ c:Int) -> Int {
    var result = 0

    if (a == b) && (a == c) {
        result = (a + b + c) * (a^2 + b^2 + c^2) * (a^3 + b^3 + c^3)
    } else if (a == b) || (b == c) || (a == c) {
        result = (a + b + c) * (a^2 + b^2 + c^2)
    } else {
        result = a + b + c
    }

    return result
}

오답 원인

• Swift에서는 ^ 연산자가 제곱이 아닌 비트 XOR 연산자로 사용된다.
• 따라서 숫자를 제곱할 때 n^2와 같은 표기법을 사용할 수 없다.

풀이 2: 수정된 코드

import Foundation

func solution(_ a:Int, _ b:Int, _ c:Int) -> Int {
    var result = 0
    let sum1 = a + b + c
    let sum2 = a*a + b*b + c*c
    let sum3 = a*a*a + b*b*b + c*c*c

    if (a == b) && (a == c) {
        result = sum1 * sum2 * sum3
    } else if (a == b) || (b == c) || (a == c) {
        result = sum1 * sum2
    } else {
        result = sum1
    }

    return result
}

pow 함수를 사용하지 않은 이유

• pow() 함수는 Double 타입에서 작동한다. 이 함수를 사용하려면 a, b, c가 Int 타입이기에, 이를 Double로 변환해야 하는 번거로움이 있다.

• 모든 계산이 Double로 이루어지므로 결과도 Double이 된다. Int 타입의 결과를 위해 한 번 더 변환이 필요하다.

• 정밀도 문제 매우 큰 숫자의 경우 부동 소수점 연산의 정밀도 한계로 인해 정확한 결과를 얻지 못할 수 있다.

• 성능 pow() 함수는 일반 곱셈보다 계산 비용이 더 크다. 특히 2제곱과 3제곱은 곱셈(*)을 통해 직접 표현하는 것이 더 효율적이다.

^ 연산이 XOR 연산으로 처리된다니. C언어와는 달라서 당연히 풀리겠거니 생각한 문제가 오답처리 돼서 당황했다. 4제곱 이상 시에는 pow 함수 쓰기, 3제곱 이하라면 직접 곱하기 기억하기.

문제 링크

풀이 1: 초기 풀이

import Foundation

func solution(_ str1:String, _ str2:String) -> String {
    var result: [Character] = []

    for n in 0..<str1.count {
        result.append(str1[str1.index(str1.startIndex, offsetBy: n)])
        result.append(str2[str2.index(str2.startIndex, offsetBy: n)])
    }

    return String(result)
}

설명

문자열의 n번째 인덱스 접근

result.append(str1[str1.index(str1.startIndex, offsetBy: n)])

• str1.startIndex: 문자열의 시작 인덱스
• str1.index(str1.startIndex, offsetBy: n): 시작점에서 n만큼 떨어진 위치의 인덱스
• str1[계산된 인덱스]: 그 인덱스 위치의 문자

💡 왜 String은 인덱스 접근이 복잡할까? Swift에서 String은 배열과 달리 정수 인덱스(n)로 직접 접근할 수 없다. 즉, str1[n]과 같은 방식으로 접근이 불가능하다. Swift의 String은 내부적으로 유니코드를 사용하고, 각 문자가 가변적인 크기를 가질 수 있기 때문에 특별한 인덱스 타입(String.Index)을 사용한다. 따라서 위와 같은 단계가 필요하다.

풀이 2: 간단한 방법

import Foundation

func solution(_ str1: String, _ str2: String) -> String {
    let str1Array = Array(str1)
    let str2Array = Array(str2)
    var result = ""

    for i in 0..<str1.count {
        result.append(str1Array[i])
        result.append(str2Array[i])
    }

    return result
}

설명

• 문자열을 먼저 Character 배열로 변환하여 인덱싱을 효율적으로 수행할 수 있다. 이렇게 하면 매번 index(startIndex, offsetBy:)를 호출하지 않아도 된다.

다른 사람의 풀이

import Foundation

func solution(_ str1:String, _ str2:String) -> String {
    return zip(str1, str2).map { String($0) + String($1) }.joined()
}

설명

zip(str1, str2)

• zip 함수는 두 시퀀스를 받아 각 시퀀스의 동일한 위치에 있는 요소들을 쌍(tuple)으로 묶어 새로운 시퀀스를 생성한다.
• 예를 들어, str1 = "abc", str2 = "xyz" 라면, zip은 [('a','x'), ('b','y'), ('c','z')]와 같은 쌍들을 생성한다.

.map { String($0) + String($1) }

• map은 각 쌍에 클로저를 적용하여 변환한다.
• 클로저 내에서 $0은 쌍의 첫 번째 요소(str1의 문자), $1은 쌍의 두 번째 요소(str2의 문자).
• 각 문자를 String으로 변환하고 두 문자열을 합친다.
• 예를 들어, ('a','x')는 "ax"가 된다.

.joined():

• 결과적으로 생성된 문자열 배열을 하나의 문자열로 합친다.
• 예를 들어, ["ax", "by", "cz"]는 "axbycz"가 된다.

문자열의 인덱스에 접근하고자 할 때에는 문자열을 배열로 만들어 쉽게 접근해보자.

풀이 1: 오류

import Foundation

func solution(_ mystring:String, * overwrite*string:String,  s:Int) -> String {
    let firstIdx = my_string.index(my_string.startIndex, offsetBy: s) // 덮어쓰기 시작 인덱스
    var result = String(my_string[..<firstIdx]) + overwrite_string // 덮어쓴 문자열

    guard let lastIdx = my_string.index(my_string.startIndex, offsetBy: s + overwrite_string.count) {
        result += String(my_string[lastIdx]...)   
    } // 덮어쓰고 남은 원본 문자열을 result에 추가

    return result
}

문제점

• guard let 구문의 잘못된 사용: index(startIndex, offsetBy:) 메서드는 옵셔널 값을 반환하지 않는다. 따라서 guard let으로 처리할 필요가 없다. 만약 요청한 인덱스가 문자열 범위를 벗어나면 이 메서드는 nil을 반환하는 것이 아니라 _런타임 오류_를 발생시킵니다.

• 슬라이싱 문법 오류: my_string[lastIdx]...에서 lastIdx는 인덱스이지만, 범위 연산자를 사용하려면 my_string[lastIdx...]와 같이 작성해야 한다.

풀이 2: 오류

import Foundation

func solution(_ mystring:String, * overwrite*string:String,  s:Int) -> String {
    let firstIdx = my_string.index(my_string.startIndex, offsetBy: s) // 덮어쓰기 시작 인덱스
    let lastIdx = my_string.index(my_string.startIndex, offsetBy: s + overwrite_string.count) // 덮어쓰기 마지막 인덱스 + 1

    var result = String(my_string[..<firstIdx]) + overwrite_string
    if my_string.count >= Int(lastIdx)  { // 남은 원본 문자가 있으면 결과 문자열에 추가
        result += String(my_string[lastIdx...])   
    }
    return result
}

문제점

• 타입 변환 오류: if my_string.count >= Int(lastIdx) 부분에서 lastIdx를 Int로 변환하려고 시도했다. 그러나 lastIdx는 String.Index 타입이으로 정수형으로 직접 변환할 수 없다.

• 불필요한 조건 검사: 문제의 제한사항에 따르면 s + overwrite_string.count는 항상 my_string.count 이하임이 보장된다. 따라서 이 조건 검사는 불필요하다.

  💡 항상 lastIdx가 my_string의 범위를 벗어나지 않는 이유? my_string.endIndex는 문자열의 길이와 같다 (즉, my_string.count와 동일한 위치). 따라서 제한사항에 의해 s + overwrite_string.count(덮어쓰기 마지막 인덱스 + 1) ≤ my_string.count가 보장되므로, lastIdx ≤ my_string.endIndex도 항상 성립한다.

풀이 3

import Foundation

func solution(_ my_string:String, _ overwrite_string:String, _ s:Int) -> String {
    let firstIdx = my_string.index(my_string.startIndex, offsetBy: s) // 덮어쓰기 시작 인덱스
    let lastIdx = my_string.index(my_string.startIndex, offsetBy: s + overwrite_string.count) // 덮어쓰기 마지막 인덱스 + 1

    let result = String(my_string[..<firstIdx]) + overwrite_string + String(my_string[lastIdx...])  

    return result
}

설명

1. 덮어쓰기 시작할 인덱스 이전까지는 원본 문자열을 저장한다.
2. 덮어쓰기 시작할 인덱스부터 덮어쓸 문자열의 끝까지를 저장한다.
3. 남은 원본 문자열을 저장한다. (혹은 남은 문자열이 없거나)

다른 사람의 풀이

import Foundation

func solution(_ myString: String, _ overwriteString: String, _ s: Int) -> String {
    var myString = Array(myString)
    myString.replaceSubrange(s...(overwriteString.count+s-1), with: Array(overwriteString))
    return String(myString)
}

설명

• 문자열을 문자 배열로 변환: var myString = Array(myString) 원본 문자열을 [Character] 타입의 배열로 변환 → Swift의 정수 인덱싱을 사용할 수 있어 작업이 단순해짐

• 부분 범위 교체: replaceSubrange 메서드는 배열의 특정 범위를 다른 요소들로 교체한다. 범위 지정은 다음과 같다.

• 시작*: s (정수 인덱스)

• 끝*: overwriteString.count+s-1 (덮어쓸 문자열의 길이를 고려한 마지막 인덱스)

• ...*는 끝 인덱스를 포함하는 닫힌 범위를 만든다. Array(overwriteString)는 덮어쓸 문자열도 문자 배열로 변환한다.

• 결과 변환 및 반환: 수정된 문자 배열을 다시 String으로 변환하여 반환

알게 된 것 정리

• my_string.index(my_string.startIndex, offsetBy: s) Int 인덱스 값으로 String.index 값 얻기

• myString.replaceSubrange(s...(overwriteString.count+s-1), with: Array(overwriteString)) 원본 배열의 a번 째부터 b번 째의 요소를 with 배열의 요소로 교체

• 문자열은 Character 배열로 변경해서 다루면 편리할 때가 있다.

Substring이란?

Substring은 기존 String의 메모리를 공유하는 부분 문자열이다. Swift에서 문자열의 일부분을 효율적으로 다루기 위해 설계되었다.

Substring이 생성되는 경우

다음과 같은 String 메서드들을 사용할 때 Substring이 반환된다.

1. prefix/suffix 메서드 사용 시:

   let hello = "Hello, World!"
   let prefix = hello.prefix(5) // "Hello"는 Substring 타입

2. split 메서드 사용 시:

   let sentence = "Apple Banana Cherry"
   let words = sentence.split(separator: " ") // [Substring] 타입 배열 반환

3. dropFirst/dropLast 메서드 사용 시:

   let text = "Swift Programming"
   let dropped = text.dropFirst(6) // "Programming"은 Substring 타입

4. 범위(Range) 연산자 사용 시:

   let str = "Hello, World!"
   if let range = str.range(of: "World") {
    let substring = str[range] // "World"는 Substring 타입
   }

String, Character, Substring의 차이점

1. Character

• 단일 표시 단위(하나의 시각적 문자)를 나타냄
• 독립적인 자체 메모리 공간 사용

2. String

• Character들의 컬렉션, 텍스트의 전체 시퀀스
• 자체 메모리 공간에서 문자열 데이터 관리

3. Substring

• 원본 String의 일부분을 나타내는 뷰(view)
• 원본 String과 메모리 공유
• 임시적인 사용 목적 (장기 저장에는 적합하지 않음)

가장 큰 차이는 메모리 관리 방식이다. Substring은 원본의 메모리만 참조하므로 빠르게 생성할 수 있다. 하지만 Substring이 존재하는 한, 원본 String의 전체 메모리는 해제되지 않는다.

원본 String의 메모리를 계속 유지한다는 것은 Substring이 참조하는 메모리가 갑자기 사라지는 것을 방지한다는 의미이다.

따라서 Substring은 임시 작업에는 효율적이지만, 장기간 저장할 필요가 있는 데이터는 반드시 String으로 변환해야 한다. let newString = Stirng(substring)

그렇다면 Substring이 String을 참조하고 있을 때, String을 변경하면 어떻게 될까?

원본 String의 값은 바뀔 수 있을까?

여기서 중요한 점은, Swift에서 String은 값 타입이라는 것이다. 값 타입은 변수에 할당될 때나 함수에 전달될 때 복사된다.

var original = "Hello, Swift Programming!"
let sub = original.dropFirst(7) // "Swift Programming!" - Substring

// original 값을 변경
original = "Changed string"

print(sub) // 여전히 "Swift Programming!" 출력

따라서 위 코드에서 original 변수의 값을 변경해도 sub은 여전히 원래 참조하던 "Swift Programming!" 부분을 가리킨다. 이는 Swift가 변수 original의 값을 변경할 때 새로운 메모리 공간을 할당하고 original 변수가 그 새 공간을 가리키게 만들기 때문이다. 원래의 메모리 공간("Hello, Swift Programming!")은 sub이 여전히 참조하고 있으므로 해제되지 않는다.

결론

Swift의 Substring은 C 언어의 포인터 개념을 생각하면 이해가 쉽겠다. (C언어에 대한 지식이 있다면 말이지) 다만 포인터와는 달리 원본 값이 바뀌면 바뀐 값은 새로운 메모리에 할당되고, 원본을 참조하던 Substring의 값은 바뀌지 않는다는 것이 큰 차이이겠다.

문제 링크

풀이 1: 오류

let s1 = readLine()!

let upper = "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z".split(separator: " ")
let lower = "a b c d e f g h i j k l m n o p q r s t u v w x y z".split(separator: " ")
var result = ""

for j in 0..<s1.count {
    for i in 0..<upper.count {
        if Character(upper[i]) == Character(s1[j]) {
            result.append(lower[i])
        } else if Character(lower[i]) == Character(s1[j]) {
            result.append(lower[i])
        }
    }
}

print(result)

문제점

1. 문자열 인덱싱 문제 Swift에서는 String 타입의 인덱싱이 직접적으로 지원되지 않는다. s1[j]와 같은 방식으로 문자열의 특정 위치에 접근할 수 없다. 문자열의 특정 위치에 접근하려면 String.Index를 사용해야 한다.

2. Substring을 Character로 변환 시도 Character(upper[i])와 Character(lower[i])에서 upper와 lower는 [Substring] 타입이므로, 각 요소는 Substring 타입이다. Substring을 직접 Character로 변환하는 것은 불가능하므로 먼저 String으로 변환한 후 Character로 변환해야 한다.

3. 비효율적인 알파벳 생성 방식 알파벳을 공백으로 구분된 문자열로 정의하고 split을 사용하는 것은 비효율적이다. 더 직관적인 방법으로는 문자 배열을 직접 정의하거나 ASCII 값을 활용하는 방법이 있다.

풀이 2

import Foundation

let s1 = readLine()!

let upper = Array("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
let lower = Array("abcdefghijklmnopqrstuvwxyz")
var result = ""

for c in s1 {
    if let index = upper.firstIndex(of: c) { // 대문자인 경우
        result.append(lower[index]) // 소문자로 반환
    } else if let index = lower.firstIndex(of: c) { // 소문자인 경우
        result.append(upper[index]) // 대문자로 반환
    } else {
        result.append(c)
    }
}

print(result)

설명

• 대소문자 알파벳 배열을 만들어 주어진 문자열을 for문으로 확인해가며 한 글자씩 변경한다.
• if let 구문을 사용한 이유는 firstIndex의 반환값이 nil 인 경우도 있기 때문이다. (해당 문제에는 nil인 경우가 없지만)

풀이 3: 최종 코드

import Foundation

let s1 = readLine()!
var result = ""

for c in s1 {
    if c.isUppercase {
        result.append(c.lowercased()) // 대문자면 소문자로 변경
    } else {
        result.append(c.uppercased()) // 소문자면 대문자로 변경
    }
}

print(result)

설명

• 알파벳 배열을 직접 만들지 않고 isUppercase 내장 속성을 사용해 대소문자 판별
• lowercased(), uppercased() 내장 메서드 사용해 대소문자 변경

👉 스위프트다운 코드 완성

매번 헷갈리던 Substring에 대한 포스트는 따로 적어두었다. https://velog.io/@juhee-dev/Swift-문법-Substring-이해하기

이슈

👉 사용자의 실시간 위치를 지도에 표시할 때, 심볼로 원형 위에 프로필이미지를 겹친 뷰를 이미지 대신 띄우는 것이 목표.

원인

👉 카카오맵에서 지원하는 마커(Poi) 형식은 UIImage로 한정되어 있어, 커스텀 마커를 띄울 수 없었음

해결

👉 심볼이 될 뷰를 만들고, Extention을 통해 뷰를 UIImage로 변환시키는 함수 작성

최종 코드

ProfileImageView:

import SwiftUI

// 프로필 이미지를 위한 SwiftUI View
struct ProfileImageView: View {
    let image: Image

    var body: some View {
        ZStack {
            Image("icon-location-anchor")
                .frame(width: LayoutAdapter.shared.scale(value: 11), height: LayoutAdapter.shared.scale(value: 11))
                .padding(.top, 55)
            Image("icon-location-pin")
                .frame(width: LayoutAdapter.shared.scale(value: 45), height: LayoutAdapter.shared.scale(value: 56))

            image
                .resizable()
                .scaledToFill()
                .frame(width: LayoutAdapter.shared.scale(value: 37), height: LayoutAdapter.shared.scale(value: 37))
                .clipShape(Circle())
                .frame(width: LayoutAdapter.shared.scale(value: 10), height: LayoutAdapter.shared.scale(value: 10))
                .padding(.bottom, 10)
        }
    }
}

Extensions:

// MARK: View to UIImage - 실시간 위치 조회시 프로필사진 마킹용
extension View {
    func snapshot() -> UIImage {
        let controller = UIHostingController(rootView: self.edgesIgnoringSafeArea(.all))
        let view = controller.view

        let targetSize = controller.view.intrinsicContentSize

        view?.bounds = CGRect(origin: .zero, size: targetSize)
        view?.backgroundColor = .clear

        let renderer = UIGraphicsImageRenderer(size: targetSize)

        return renderer.image { _ in
            view?.drawHierarchy(in: controller.view.bounds, afterScreenUpdates: true)
        }
    }
}

// MARK: 이미지 크기 조절
extension UIImage {
    func resizedForProfile(to size: CGSize) -> UIImage {
        return UIGraphicsImageRenderer(size: size).image { _ in
            draw(in: CGRect(origin: .zero, size: size))
        }
    }
}

MapPinView:

// Poi 표시 스타일 생성
        func createPoiStyle() {
            guard let view = controller?.getView(mapViewName) as? KakaoMap else {
                print("view is nil in createPoiStyle")
                return
            }
            let manager = view.getLabelManager()

            // 내 마커용 스타일 생성: SwiftUI View를 UIImage로 변환
            let myMarker = ProfileImageView(image: Image(myLocation?.member?.profileImage ?? "icon-profile-default"))
            let mySymbolImage = myMarker.snapshot().resizedForProfile(to: CGSize(width: LayoutAdapter.shared.scale(value: 30), height: LayoutAdapter.shared.scale(value: 40.667)))
            let myIconStyle = PoiIconStyle(symbol: mySymbolImage, anchorPoint: CGPoint(x: 0.5, y: 1))
            let myPoiStyle = PoiStyle(styleID: "myPoiStyle", styles: [
                PerLevelPoiStyle(iconStyle: myIconStyle, level: 12)
            ])
            manager.addPoiStyle(myPoiStyle)

            // 친구들 각각의 마커 스타일 생성
            for (index, friend) in friendsLocation.enumerated() {
                let profileImageName = friend.member?.profileImage ?? "icon-profile-default"
                let friendMarker = ProfileImageView(image: Image(profileImageName))
                let friendSymbolImage = friendMarker.snapshot().resizedForProfile(to: CGSize(width: LayoutAdapter.shared.scale(value: 30), height: LayoutAdapter.shared.scale(value: 40.667)))
                let friendIconStyle = PoiIconStyle(symbol: friendSymbolImage, anchorPoint: CGPoint(x: 0.5, y: 1))

                // 각 친구별로 고유한 styleID 생성
                let styleID = "friendPoiStyle_\(index)"
                let friendPoiStyle = PoiStyle(styleID: styleID, styles: [
                    PerLevelPoiStyle(iconStyle: friendIconStyle, level: 12)
                ])
                manager.addPoiStyle(friendPoiStyle)
            }
        }

        func createPois() {
            guard let view = controller?.getView(mapViewName) as? KakaoMap else {
                print("view is nil in createPois")
                return
            }
            let manager = view.getLabelManager()
            let layer = manager.getLabelLayer(layerID: "PoiLayer")

            // 내 위치 POI 생성
            let myPoiOption = PoiOptions(styleID: "myPoiStyle")
            myPoiOption.rank = 0

            if let myLocation {
                let myPoi = layer?.addPoi(
                    option: myPoiOption,
                    at: MapPoint(longitude: myLocation.x, latitude: myLocation.y)
                )
                myPoi?.show()
            }

            // 친구들 위치 POI 생성 - 각각 다른 스타일 적용
            for (index, friend) in friendsLocation.enumerated() {
                let friendPoiOption = PoiOptions(styleID: "friendPoiStyle_\(index)")
                friendPoiOption.rank = 1

                let friendPoi = layer?.addPoi(
                    option: friendPoiOption,
                    at: MapPoint(longitude: friend.x, latitude: friend.y)
                )
                friendPoi?.show()
            }
        }

참고 https://stickode.tistory.com/448

이슈

👉 사용자의 실시간 위치를 지도에 띄울 때, 위치 좌표값은 정상적으로 받지만 카카오맵이 보이지 않음

원인

👉 실제 위치를 사용할 때에는 viewModel.userLatitude와 viewModel.userLongitude가 초기값 0으로 시작하고, 위치 업데이트를 받은 후에야 실제 값으로 변경됨. MapPinView에는 위치가 업데이트될 때 지도를 새로 그리는 로직이 없음

해결

👉 위치를 보여주는 FriendsLocationView, 카카오맵 보여주는 컨테이너인 MapPinView에 위치 업데이트 로직 생성 MapPinView.swift:

class KakaoMapCoordinator: NSObject, MapControllerDelegate {
                ...

                // location 값이 변경될 때 지도 업데이트를 위한 메서드 추가
        func updateLocation(_ newLocation: Location) {
            self.location = newLocation

            guard let view = controller?.getView("mapview") as? KakaoMap else {
                print("view is nil in updateLocation")
                return
            }

            // 기존 POI 삭제
            let manager = view.getLabelManager()
            if let layer = manager.getLabelLayer(layerID: "PoiLayer") {
                layer.clearAllItems() // TODO: 맞는 메서드인지 확인 필요
            }

            // 새로운 POI 생성
            createPois()

            // 카메라 이동
            let cameraUpdate = CameraUpdate.make(
                target: MapPoint(longitude: newLocation.x, latitude: newLocation.y),
                mapView: view
            )
            view.moveCamera(cameraUpdate)
        }
}

FriendsLocationView.swift:

var body: some View {
    ZStack {
                ...
    }
    .onChange(of: viewModel.userLatitude) { _, _ in
        updateLocation()
    }
    .onChange(of: viewModel.userLongitude) { _, _ in
        updateLocation()
    }
}

짧은 지식💡 x:0, y: 0 좌표는 널 아일랜드라고 한다. 하핫.

카카오맵은 좌표가 이상하면 스카이블루 스크린을 띄워주는 듯. 다음에 같은 화면이 보이면 가장 먼저 좌표 동기화 문제를 의심해봐야겠다.

이슈

하루종일 토글을 키고 시작일 날짜를 바꿀 경우 화면에서는 종료일 날짜도 동일하게 변경되지만 실제 변수값은 오늘 날짜에서 바뀌지 않는다.

원인

초기화 부분에서는 기본 종료시간을 무조건 시작일 기준으로 1시간 후로 설정하고 있다. 그러나 하루종일 토글값이 변경될 때와 시작일이 변경될 때, 종료일을 시작일과 동기화하는 로직이 없기에 → 시작일을 10일 뒤로 바꿔도 종료일은 여전히 10일 전으로 설정되어 있던 것.

// 일정 시작일, 종료일 초기화 코드
let endOfHour = calendar.date(byAdding: .hour, value: 1, to: startOfHour)!
self.endTime = endOfHour

해결

하루종일 토글이 켜질 때와 일정 시작일이 바뀔 때, 종료일을 시작일과 동기화하도록 수정

@Published var isAllDay: Bool = true {
    didSet {
        if isAllDay {
        // 하루종일이 켜지면 종료일을 시작일과 동일하게 설정
        endTime = Calendar.current.startOfDay(for: startTime)
        }
    }
}
@Published var startTime: Date {
    didSet {
        if isAllDay {
        // 하루종일일 때 시작일이 변경되면 종료일도 함께 변경
        endTime = Calendar.current.startOfDay(for: startTime)
        }
    }
}

💡 didSet 이란? 프로퍼티 옵저버의 종류. 프로퍼티의 값이 변경된 직후에 호출되는 코드 블록을 정의할 수 있게 한다.

프로퍼티 옵저버의 두 가지:

1. willSet: 값이 변경되기 직전에 호출
2. didSet: 값이 변경된 직후에 호출

변수의 초기화뿐 아니라 동기화 등 비즈니스 로직에 대해서도 세심하게 신경쓰자.

이슈

캘린더뷰 상단에 원하지 않는 여백이 생김. 프리뷰로 보면 정상적이나 시뮬레이터로 확인하면 나타나는 현상.

시도한 방법들

1. 프로젝트에서 SwiftUI와 UIKit을 함께 사용하고 있는데, 호환의 문제인가 싶어 ScheduleView를 UIKit으로 변환해서 해결하려고 했으나 Force Cast Violation: Force casts should be avoided (force_cast) 오류 발생.

2. 여전히 호환 문제라고 생각해서 기존 UIKit 탭바를 래핑해서 하단 탭바를 SwiftUI로 사용하니 문제 해결됨. 다만 기존의 UIKit 뷰에서 상단 툴바가 사라지는 문제 발생(빈대 잡으려다 초가삼간 태우는 꼴)

이외 여러가지 시도했으나 해결되지 않음

원인

뷰 계층구조를 확인하니 하단탭바에서 일정 탭을 클릭하면 UINavigationBar → _UIBarBackground가 쌓여서 추가적인 여백이 발생했다.

그래서 하단 탭바를 다른 방식으로 구현했을때 문제가 해결되었던 것.

해결🥳

_UIBarBackground를 제거하거나 높이를 0으로 만들고 싶었지만 적용되지 않아서 상위 컨테이너인 UINavigationBar를 제거했다.

// ScheduleView를 UINavigationController로 감싸서 사용
let scheduleHostingVC = UIHostingController(rootView: ScheduleView())
let scheduleNavVC = UINavigationController(rootViewController: scheduleHostingVC)  // UINavigationController로 감싸기
scheduleHostingVC.tabBarItem = UITabBarItem(...)

viewControllers = [mainVC, scheduleNavVC, friendsVC, myPageVC]  // NavigationController를 탭에 추가

기존 코드 ⬇️ 수정된 코드

// ScheduleView를 UIHostingController만 사용
let scheduleHostingVC = UIHostingController(rootView: ScheduleView())  // UINavigationController로 감싸지 않음
scheduleHostingVC.tabBarItem = UITabBarItem(...)

viewControllers = [mainVC, scheduleHostingVC, friendsVC, myPageVC]  // HostingController를 직접 탭에 추가

주요 차이점

1. UINavigationController 레이어가 제거됨
2. 불필요한 UINavigationBar가 생성되지 않음
3. 뷰 계층이 더 단순해짐 (HostingController -> ScheduleView)

앞으로는 뷰에 의도하지 않은 배치나 여백이 생기는 경우에는 뷰 계층 구조를 확인해보자.

시뮬레이터를 실행한 채 하단의 저 버튼을 누르면 뷰 구조를 볼 수 있고, 아무 컴포넌트를 클릭 후 드래그 하면 입체적으로 구조를 확인할 수 있다.

xcode에서 이런 기능을 지원하는 줄 몰랐다. 알려준 동료분께 무한 감사를...

목표

• SwiftUI를 사용하여 카카오맵 띄우기
• 공식 가이드대로 쓴 코드의 오류 해결하기

기존 코드

import SwiftUI
import KakaoMapsSDK

struct MapView: View {
    @State var draw: Bool = true   // 뷰의 appear 상태를 전달하기 위한 변수.

    init() {
        SDKInitializer.InitSDK(appKey: Config.kakaoAppKey)
    }

    var body: some View {
        KakaoMapView(draw: $draw)
            .onAppear(perform: {
                self.draw = true
            })
            .onDisappear(perform: {
                self.draw = false
            })
            .frame(maxWidth: .infinity, maxHeight: .infinity)
    }
}

struct KakaoMapView: UIViewRepresentable {
    @Binding var draw: Bool

    /// UIView를 상속한 KMViewContainer를 생성한다.
    /// 뷰 생성과 함께 KMControllerDelegate를 구현한 Coordinator를 생성하고, 엔진을 생성 및 초기화한다.
    func makeUIView(context: Self.Context) -> KMViewContainer {
        let view: KMViewContainer = KMViewContainer()
        view.sizeToFit()
        context.coordinator.createController(view)
        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            context.coordinator.controller?.prepareEngine()
            print("makeUIView - Engine prepared!")
        }

        return view
    }

    /// Updates the presented `UIView` (and coordinator) to the latest configuration.
    /// draw가 true로 설정되면 엔진을 시작하고 렌더링을 시작한다.
    /// draw가 false로 설정되면 렌더링을 멈추고 엔진을 stop한다.
    func updateUIView(_ uiView: KMViewContainer, context: Self.Context) {
        if draw {
            context.coordinator.controller?.activateEngine()
            print("updateUIView - Engine activated!")
        } else {
            context.coordinator.controller?.resetEngine()
        }
    }

    /// Coordinator 생성
    func makeCoordinator() -> KakaoMapCoordinator {
        return KakaoMapCoordinator()
    }

    /// Cleans up the presented `UIView` (and coordinator) in anticipation of their removal.
    static func dismantleUIView(_ uiView: KMViewContainer, coordinator: KakaoMapCoordinator) {

    }

    /// Coordinator 구현. KMControllerDelegate를 adopt한다.
    class KakaoMapCoordinator: NSObject, MapControllerDelegate {
        var controller: KMController?
        var first: Bool

        override init() {
            first = true
            super.init()
        }

        // KMController 객체 생성 및 event delegate 지정
        func createController(_ view: KMViewContainer) {
            controller = KMController(viewContainer: view)
            controller?.delegate = self
        }

        // KMControllerDelegate Protocol method구현

        // 엔진 생성 및 초기화 이후, 렌더링 준비가 완료되면 아래 addViews를 호출한다.
        // 원하는 뷰를 생성한다.
        func addViews() {
            let defaultPosition: MapPoint = MapPoint(longitude: 127.108678, latitude: 37.402001)
            let mapviewInfo: MapviewInfo = MapviewInfo(viewName: "mapview", viewInfoName: "map", defaultPosition: defaultPosition)

            controller?.addView(mapviewInfo)
        }

        // addView 성공 이벤트 delegate. 추가적으로 수행할 작업을 진행한다.
        func addViewSucceeded(_ viewName: String, viewInfoName: String) {
            print("OK") // 추가 성공. 성공시 추가적으로 수행할 작업을 진행한다.
        }

        // addView 실패 이벤트 delegate. 실패에 대한 오류 처리를 진행한다.
        func addViewFailed(_ viewName: String, viewInfoName: String) {
            print("Failed")
        }

        func authenticationSucceeded() {
            print("auth succeed!!")
        }

        func authenticationFailed(_ errorCode: Int, desc: String) {
            print("auth failed")
            print("error code: \(errorCode)")
            print(desc)
            //            print(controller?.getStateDescMessage())
        }

        // KMViewContainer 리사이징 될 때 호출.
        func containerDidResized(_ size: CGSize) {
            let mapView: KakaoMap? = controller?.getView("mapview") as? KakaoMap
            mapView?.viewRect = CGRect(origin: CGPoint(x: 0.0, y: 0.0), size: size)
            if first {
                let cameraUpdate: CameraUpdate = CameraUpdate.make(target: MapPoint(longitude: 127.108678, latitude: 37.402001), zoomLevel: 10, mapView: mapView!)
                mapView?.moveCamera(cameraUpdate)
                first = false
            }
        }

    }
}

트러블 슈팅

이슈

• 카카오맵 키 인증까지는 정상적으로 되지만 지도 뷰가 뜨지 않고 연한 초록색으로만 표시됨

원인

1️⃣

• 뷰를 처음 그리는 경우 명시적으로 엔진을 활성화해야 함.
• 공식 문서에 따르면 KakaoMapsSDK의 라이프 사이클은 엔진 초기상태 → 인증 시작 → 엔진 대기 → 인증 성공 → 엔진 활성 → 지도 그리기 순으로 진행됨.
• 인증 성공 후 직접 엔진 활성 코드를 호출하지 않았기 때문에 다음 작업인 지도 그리기가 진행되지 않았던 것.

2️⃣

• 엔진 대기, 인증하는 과정에서 SDK 라이프사이클이 꼬임

🌟 해결

• 인증이 완료되면 명시적으로 엔진을 활성화 함.
• 또한 엔진 대기 부분을 비동기적으로 처리해 라이프사이클 문제를 해결함.

최종 코드

기존 코드에서 달라진 부분은 🌟로 표시해두었다.

import SwiftUI
import KakaoMapsSDK

struct MapView: View {
    @State var draw: Bool = false // 뷰의 appear 상태를 전달하기 위한 변수.

    // 🌟 SDKInitializer는 AppDelegate에서 이미 설정했으므로 중복된 기능 제외

    var body: some View {
        KakaoMapView(draw: $draw)
            .onAppear(perform: {
                self.draw = true
            })
            .onDisappear(perform: { self.draw = false   })
            .frame(maxWidth: .infinity, maxHeight: .infinity)
    }
}

struct KakaoMapView: UIViewRepresentable {
    @Binding var draw: Bool

    /// UIView를 상속한 KMViewContainer를 생성한다.
    /// 뷰 생성과 함께 KMControllerDelegate를 구현한 Coordinator를 생성하고, 엔진을 생성 및 초기화한다.
    func makeUIView(context: Self.Context) -> KMViewContainer {
        let view: KMViewContainer = KMViewContainer()
        view.sizeToFit()
        context.coordinator.createController(view)
        // 🌟 prepareEngine 비동기적 처리하지 않으면 맵 보이지 않음. 
        // 🌟 DispatchQueue.main.asyncAfter(deadline: .now() + 2) 사용해도 되지만 대기시간이 있어 async()보다 뷰가 느리게 뜸
        DispatchQueue.main.async() {
            context.coordinator.controller?.prepareEngine()
            print("makeUIView - Engine prepared!")
        }

        return view
    }

    /// Updates the presented `UIView` (and coordinator) to the latest configuration.
    /// draw가 true로 설정되면 엔진을 시작하고 렌더링을 시작한다.
    /// draw가 false로 설정되면 렌더링을 멈추고 엔진을 stop한다.
    func updateUIView(_ uiView: KMViewContainer, context: Self.Context) {
        if draw {
            context.coordinator.controller?.activateEngine()
            print("updateUIView - Engine activated!")
        } else {
            context.coordinator.controller?.resetEngine()
        }
    }

    /// Coordinator 생성
    func makeCoordinator() -> KakaoMapCoordinator {
        return KakaoMapCoordinator()
    }

    /// Cleans up the presented `UIView` (and coordinator) in anticipation of their removal.
    static func dismantleUIView(_ uiView: KMViewContainer, coordinator: KakaoMapCoordinator) {

    }

    /// Coordinator 구현. KMControllerDelegate를 adopt한다.
    class KakaoMapCoordinator: NSObject, MapControllerDelegate {
        var controller: KMController?
        var first: Bool

        override init() {
            first = true
            super.init()
        }

        // KMController 객체 생성 및 event delegate 지정
        func createController(_ view: KMViewContainer) {
            controller = KMController(viewContainer: view)
            controller?.delegate = self
        }

        // KMControllerDelegate Protocol method구현

        // 엔진 생성 및 초기화 이후, 렌더링 준비가 완료되면 아래 addViews를 호출한다.
        // 원하는 뷰를 생성한다.
        func addViews() {
            let defaultPosition: MapPoint = MapPoint(longitude: 127.108678, latitude: 37.402001)
            let mapviewInfo: MapviewInfo = MapviewInfo(viewName: "mapview", viewInfoName: "map", defaultPosition: defaultPosition)

            controller?.addView(mapviewInfo)
        }

        // addView 성공 이벤트 delegate. 추가적으로 수행할 작업을 진행한다.
        func addViewSucceeded(_ viewName: String, viewInfoName: String) {
            print("OK") // 추가 성공. 성공시 추가적으로 수행할 작업을 진행한다.
        }

        // addView 실패 이벤트 delegate. 실패에 대한 오류 처리를 진행한다.
        func addViewFailed(_ viewName: String, viewInfoName: String) {
            print("Failed to add view")
        }

        func authenticationSucceeded() {
            print("auth succeed!!")
            print(controller?.isEnginePrepared)
            print(controller?.isEngineActive)
            // 🌟 인증이 완료되면 엔진을 활성화시킨다.
            if let controller = controller,
               !controller.isEngineActive {
                controller.activateEngine()
            }
        }

        func authenticationFailed(_ errorCode: Int, desc: String) {
            print("auth failed")
            print("error code: \(errorCode)")
            print(desc)
        }

        // KMViewContainer 리사이징 될 때 호출.
        func containerDidResized(_ size: CGSize) {
            let mapView: KakaoMap? = controller?.getView("mapview") as? KakaoMap
            mapView?.viewRect = CGRect(origin: CGPoint(x: 0.0, y: 0.0), size: size)
            if first {
                let cameraUpdate: CameraUpdate = CameraUpdate.make(target: MapPoint(longitude: 127.108678, latitude: 37.402001), zoomLevel: 10, mapView: mapView!)
                mapView?.moveCamera(cameraUpdate)
                first = false
            }
        }

    }
}

#Preview {
    MapView()
}

며칠을 고생하다가 드디어 지도 안보이는 이슈를 해결했다.

KakaoMapsSDK가 최근에 V2로 바뀜 + 계속 업데이트 되는 중 이슈로 생각보다 자료가 적었는데 해결되어 다행이다.👍

• Moya 라이브러리 사용
• 사용자 ID를 request query로 보내 서버와 통신
• get 방식 사용
• 최종: 즐겨찾기 목록(배열) 가져오기

  💡 request query? URI 주소 바깥 부분(? 이후)에 변수를 담는 방식 ex) https🩵://juhee.com/location?memberSeq=1

1. 어떤 통신을 할 것인가: Service API 작성

import Foundation
import Moya

enum LocationAPI {
    case getLocation(memberSeq: Int) // request query에 필요한 memberSeq
}

extension LocationAPI: TargetType {
    var baseURL: URL {
        return URL(string: Config.baseURL)! // 통신할 서버의 기본 주소
    }

    var path: String {
        switch self {
        case .getLocation(let memberSeq):
            return "/location" // 상세 주소
        }
    }

    var method: Moya.Method {
        switch self {
        case .getLocation:
            return .get // http method
        }
    }

    var task: Task {
        switch self {
        case .getLocation(let memberSeq): // ["key": value] 형식으로 파라미터 작성
            return .requestParameters(parameters: ["memberSeq": memberSeq], encoding: URLEncoding.queryString)
        }
    }

    var headers: [String: String]? {
        return ["Content-Type": "application/json"]
    }

    var sampleData: Data {
        return Data()
    }
}

💥 처음에는 path 리턴값을 return "/location?memberSeq=\(memberSeq)"로 작성했다가 오류가 났다. 🌟 원인은 task 부분에 이미 쿼리 파라미터를 작성해 "/location?memberSeq=1&memberSeq=1"과 같은 형태의 URL이 되었던 것.

2. 받아오는 데이터는 어떤 형식인가: Response Model

JSON 파싱을 위한 모델링이 필요하다. 데이터가 사진과 같이 배열로 들어오기 때문에, 큰 틀과 그 안에 담길 작은 틀(data 배열) 두 개로 모델링했다.

2.1. 큰 틀

import Foundation

struct GenericResponse<T: Codable>: Codable {
    let status: Int
    let message: String
    let data: T
}

2.2. 작은 틀

import Foundation

struct FavLocation: Codable {
    let locationSeq: Int
    let location: String
    let streetName: String
}

typealias GetFavLocationResponse = [FavLocation]

3. 실제 작동부: ViewModel

import SwiftUI
import Moya

final class CreateScheduleViewModel: ObservableObject {
    @Published var favPlaces: [Place] = []

    func getFavoriteLocation() {
        let provider = MoyaProvider<LocationAPI>()
        let memberSeq = 1 // 실제 사용 시에는 현재 로그인한 사용자의 memberSeq를 사용해야 합니다.

        provider.request(.getLocation(memberSeq: memberSeq)) { result in
            switch result {
            case .success(let response):
                if response.statusCode == 200 {
                    do {
                        let decoder = JSONDecoder()
                        let genericResponse = try decoder.decode(GenericResponse<GetFavLocationResponse>.self, from: response.data)

                        DispatchQueue.main.async {
                            self.favPlaces = genericResponse.data.map { location in
                                Place(location: location.location,
                                      streetName: location.streetName)
                            }
                            print("즐겨찾기 위치 로드 성공: \(self.favPlaces.count)개의 위치를 받았습니다.")
                        }
                    } catch {
                        print("JSON 디코딩 실패: \(error.localizedDescription)")
                    }
                } else {
                    print("서버 오류: \(response.statusCode)")
                    if let json = try? response.mapJSON() as? [String: Any],
                       let detail = json["detail"] as? String {
                        print("상세 메시지: \(detail)")
                    }
                }
            case .failure(let error):
                print("요청 실패: \(error.localizedDescription)")
            }
        }
    }
}

작동부에서 오류가 가장 많이 나기 때문에 오류 확인 메시지는 자세하면 자세할 수록 좋다.

• case "요청 실패": 서버 접근 불가
• case "서버 오류": 요청이 서버에 도달했지만 올바르게 처리되지 못함. 1번으로 돌아가 API 명세서와 내 코드가 올바르게 매칭되는지(http method 등) 확인해보자.
• case "JSON 디코딩 실패": JSON 파싱 실패. 2번으로 돌아가 Response 모델링이 적절한지 다시 확인하자. 이것만 해결하면 통신 성공!

💥 실제로 구현하며 URL의 쿼리 파라미터 중복 문제로 서버 오류가, GenericResponse를 만들어두고 사용하지 않고 GetFavLocationResponse로만 JSON 파싱해서 디코딩 실패 오류가 났었다. 🌟 오류 메시지를 통해 어느 단계에서 오류가 발생하는지 깨닫고, API 명세서와 코드를 비교해보니 문제를 해결할 수 있었다.

참고 https://mini-min-dev.tistory.com/110 https://www.youtube.com/watch?v=OKbJLGhUWZI&t=612s

스택

• 선입후출: 박스 쌓기
• 리스트 선언 후 append()와 pop()으로 구현
• 컴퓨터 메모리 내부에 쌓이므로 스택을 사용해야할 때 구현상 재귀함수를 이용하는 경우가 많음

큐

• 선입선출: 줄 서있는 사람들
• deque 라이브러리 사용 필요 -> append()와 popleft()로 구현
• 리스트로도 사용할 수 있지만, pop 시 요소를 앞 인덱스로 하나씩 당겨오는 작업이 생겨 비효율적이며 O(n)만큼의 시간복잡도 발생 -> 덱을 이용하자.

  from collections import deque

재귀함수

예시 문제: GCD - 유클리드 호제법

코드

def gcd (a, b):
  if a % b== 0:
    return b
  else:
    return gcd(b, a % b)

print(gcd(192, 162))

함수의 동작 구조 상 a와 b의 크기에 따른 순서는 상관이 없다.

DFS: 깊이 우선 탐색

• 깊은 부분 우선적으로 탐색
• 스택 자료구조 or 재귀함수 이용

  코드

  # DFS 메서드 정의
  def dfs(graph, v, visited):
  # 현재 노드를 방문 처리
  visited[v] = True
  print(v, end=' ')
  # 현재 노드와 연결된 다른 노드를 재귀적으로 방문
  for i in graph[v]:
    if not visited[i]:
      dfs (graph, i, visited)
  

각 노드가 연결된 정보를 표현 (2차원 리스트)

graph = [ [], [2, 3, 8], [1, 7], [1, 4, 5], [3, 5], [3, 4], [7], [2, 6, 8], [1, 7] ]

각 노드가 방문된 정보를 표현 (1차원 리스트)

visited = [False] * 9

정의된 DFS 함수 호출

dfs(graph, 1, visited)

# BFS: 너비 우선 탐색
- 가까운 노드부터 탐색 -> 간선의 비용이 모두 같을 때 최단거리 찾기 위해 사용
- 큐 자료구조 이용

### 코드
```py
from collections import deque

# BFS 메서드 정의
def bfs(graph, start, visited):
  # 큐(Queue) 구현을 위해 deque 라이브러리 사용
  queue = deque([start])
  # 현재 노드를 방문 처리
  visited[start] = True
  # 큐가 빌 때까지 반복
  while queue:
    # 큐에서 하나의 원소를 뽑아 출력하기
    v = queue.popleft()
    print(v, end='")
    # 아직 방문하지 않은 인접한 원소들을 큐에 삽입
    for i in graph[v]:
      if not visited[i]:
        queue.append (i)
        visited[i] = True

# 각 노드가 연결된 정보를 표현 (2차원 리스트)
graph = [
  [],
  [2, 3, 8],
  [1, 7], 
  [1, 4, 5], 
  [3, 5],
  [3, 4],
  [7],
  [2, 6, 8],
  [1, 7]
]

# 각 노드가 방문된 정보를 표현 (1차원 리스트)
visited = [False] * 9

# 정의된 BFS 함수 호출
bfs(graph, 1, visited)

예시 문제 1: 음료수 얼려 먹기

코드

# DFS로 특정 노드를 방문하고 연결된 모든 노드들도 방문
def dfs(x, y):
  # 주어진 범위를 벗어나는 경우에는 즉시 종료
  if x <= -1 or x >= N or y <= -1 or y >= M:
    return False

  # 현재 노드를 아직 방문하지 않았다면
  if graph[x][y] == 0:
    # 해당 노드 방문 처리
    graph[x][y] = 1
    # 상하좌우의 위치들도 모두 재귀적으로 호출
    dfs(x - 1, y)
    dfs(x, y - 1)
    dfs(x + 1, y)
    dfs(x, y + 1)
    return True
  return False

N, M = map(int, input().split())

graph = []
for _ in range(N):
  graph.append(list(map(int, input())))

result = 0
for n in range(N):
  for m in range(M):
    # 현재 위치에서 dfs 수행
    if dfs(n, m) == True:
      result += 1

print(result)

예시 문제 2: 미로 탈출

코드

from collections import deque

def bfs(x, y):
  # 큐 구현을 위해 deque 라이브러리 사용
  queue = deque()
  queue.append((x, y))

  # 큐가 빌 때까지 반복하기
  while queue:
    x, y = queue.popleft()
    # 현재 위치에서 4가지 방향으로서의 위치 확인
    for i in range(4):
      nx = x + dx[i]
      ny = y + dy[i]
      # 미로 찾기 공간을 벗어난 경우 무시
      if nx < 0 or nx >= N or ny < 0 or ny >= M:
        continue
      # 벽인 경우 무시
      if graph[nx][ny] == 0:
        continue
      # 해당 노드를 처음 방문하는 경우에만 최단 거리 기록
      if graph[nx][ny] == 1:
        graph[nx][ny] = graph[x][y] + 1
        queue.append((nx, ny))
  # 가장 오른쪽 아래까지의 최단 거리 반환
  return graph[N - 1][M - 1]


N, M = map(int, input().split())

graph = []
for _ in range(N):
  graph.append(list(map(int, input())))

# 이동할 네 가지 방향 정의 - 상, 하, 좌, 우
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

print(bfs(0, 0))

그리디 알고리즘

개념

➡️ 그리디 알고리즘으로 나온 결과는 19. 그러나 최대값은 21

이처럼 최적의 해를 보장할 수 없을 때가 많음 But, 코딩 테스트에서의 대부분의 그리디 문제는 탐욕법으로 얻은 해가 최적의 해가 되는 경우에 한해 문제 출제됨

예시 문제 1: 거스름 돈

해결 아이디어

• 최적의 해를 빠르게 구하기 위해서 가장 큰 화폐 단위부터 돈을 거슬러 주기
  • N원을 거슬러 줘야 할 때, 가장 먼저 500원으로 거슬러 줄 수 있을 만큼 거슬러 주기
  • 이후에 100원, 50원, 10원짜리 동전을 차례대로 거슬러 줄 수 있을 만큼 거슬러 주기

정당성 분석

• 가장 큰 화폐 단위부터 돈을 거슬러 주는 것이 최적의 해를 보장하는 이유는?
  • 가지고 있는 동전 중에서 큰 단위가 항상 작은 단위의 배수이므로 작은 단위의 동전들을 종합해 다른 해가 나올 수 없기 때문

• 만약에 800원을 거슬러 주어야 하는데 화폐 단위가 500원, 400원, 100원이라면?
  • 그리디 알고리즘으로는 500x1 + 100x3, 즉 4개를 거슬러줘야 함
  • 그러나 최적의 방법은 400x2, 즉 2개

• 그리디 알고리즘 문제에서는 이처럼 문제 풀이를 위한 최소한의 아이디어를 떠올리고 이것이 정당한지 검토할 수 있어야 함

답안 예시

n = 1260
count = 0

#큰 단위의 화폐부터 차례대로 확인하기
array = [500, 100, 50, 10J

for coin in array:
    count += n // coin # 해당 화폐로 거슬러 줄 수 있는 동전의 개수 세기
    n %= coin

print(count)

• 화폐의 종류가 K개 할 때, 소스코드의 시간 복잡도는 O(K)

• 이 알고리즘의 시간 복잡도는 거슬러줘야 하는 금액과는 무관하며, 동전의 총 종류에만 영향 받음

예시 문제 2: 1이 될 때까지

해결 아이디어

• 주어진 N에 대하여 최대한 많이 나누기를 수행
  • N의 값을 줄일 때 2 이상의 수로 나누는 작업이 1을 빼는 작업보다 수를 훨씬 많이 줄일 수 있음

• 우선 N이 K로 나누어 떨어지면 나누고, 그렇지 않으면 1씩 빼며 나누어 떨어지는 수로 만들어 나누기

답안 예시

# N, K을 공백을 기준으로 구분하여 입력 받기
n, k = map(int, input().split())

result = 0

while True:
    #N이 K로 나누어 떨어지는 수가 될 때까지 빼기
    target = (n // k) * k # N이 K로 나누어 떨어지지 않을 경우 N과 가장 가까운, K로 나누어 떨어지는 수 구하기
    result += (n - target) # 1을 빼는 연산 수행의 횟수 구하기
    n = target

    # N이 K보다 작을 때 (더 이상 나눌 수 없을 때) 반복문 탈출
    if n < k:
        break

    # K로 나누기
    result += 1
    n //= k

# 마지막으로 남은 수에 대하여 1씩 빼기
result += (n - 1)
print (result)

• 반복문 안에서 조건문을 사용해 뺄지, 나눌지 정할 수도 있음. O(n)

• 그러나 위 예시코드는 반복문을 거칠 떄마다 나눗셈 수행하므로 기하급수적으로 빨라짐. O(logn)

구현 알고리즘

예시 문제: 왕실의 나이트

그리디 aka 구현 aka 시뮬레이션 aka 완전 탐색 문제

답안 예시

# 현재 나이트의 위치 입력받기
pos = input()
row = int(pos[1])
col = int(ord(pos[0]) - ord('a')) + 1

# 나이트가 이동할 수 있는 8가지 방향 정의
steps = [(-2, -1), (-2, 1), (2, -1), (2, 1), (1, -2), (1, 2), (-1, 2), (-1, -2)]

# 8가지 방향에 대하여 각 위치로 이동이 가능한지 확인
result = 0
for step in steps:
  # 이동하고자 하는 위치 확인
  next_row = row + step[0]
  next_col = col + step[1]
  # 해당 위치로 이동이 가능하다면 카운트 증가
  if next_row < 1 or next_row > 8 or next_col < 1 or next_col > 8:
    continue
  result += 1 

print(result)

좌표를 움직이는 시뮬레이션 문제의 경우 steps와 같이 한 번 움직일 시 변경되는 좌표를 튜플로 만들어놓고, for문을 돌리는 방식으로 풀어가면 될 것 같다.

알고리즘 성능 평가

수 자료형

• 해당 방법은 실수형으로 표현됨

• 정수형으로 바꾸려면 a = int(1e9)

  실수형 반올림

  

리스트 자료형

리스트 = 배열 = 테이블

# 크기가 N이고, 모든 값이 0인 1차원 리스트 초기화
n = 10
a = [0] * n
print(a)

a= [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 뒤에서 세 번째 원소 출력: 인덱싱
print(a[-3])

# 두 번째 원소부터 네 번째 원소까지: 슬라이싱(:) 사용
print(a[1 : 4]) # 결과: [2, 3, 4]

리스트 컴프리헨션

# 0부터 9까지의 수를 포함하는 리스트
array = [i for i in range(10)]
print(array)
# 결과: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 0부터 19까지의 수 중에서 홀수만 포함하는 리스트
array = [i for i in range(20) if i % 2 == 1]

# 1부터 9까지의 수들의 제곱 값을 포함하는 리스트
array = [i * i for i in range(1, 10)]

# N X M 크기의 2차원 리스트 초기화
n = 4
m = 3
array = [[0] * m for _ in range(n)] # 길이가 m인 리스트를 n개 만든다.
print(array)
# 결과: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

💡 언더바는 언제 사용하나요?

리스트 관련 기타 메서드

a = [1, 2, 3, 4, 5, 5, 5]
remove_set = {3, 5} # 집합 자료형 (집합 자료형은 추후에 다시 다릅니다.)

# remove_list에 포함되지 않은 값만을 저장
result = [i for i in a if i not in remove_set]
print(result)
# 결과: [1, 2, 4]

문자열 자료형

• 리스트와같이 인덱싱, 슬라이싱 가능 but, 변경은 불가능(immutable)

튜플 자료형

• 리스트와 비슷 but, 변경은 불가능
• 리스트에 비해 상대적으로 공간 효율적

  array = [('홍길동', 50), ('이순신', 32), ('아무개', 74)]

튜플을 사용하면 좋은 경우

• 서로 다른 성질의 데이터를 묶어서 관리해야 할 때

  • 최단 경로 알고리즘에서는 (비용, 노드 번호)의 형태로 튜플 자료형을 자주 사용합니다.

• 데이터의 나열을 해싱(Hashing)의 키 값으로 사용해야 할 때

  • 튜플은 변경이 불가능하므로 리스트와 다르게 키 값으로 사용될 수 있습니다.

• 리스트보다 메모리를 효율적으로 사용해야 할 때

사전 자료형

• 키(Key)와 값(Value)의 쌍

• 순서가 없음

• 원하는 '변경 불가능한(Immutable) 자료형'을 키로 사용 가능

• 파이썬의 사전 자료형은 해시 테이블(Hash Table)을 이용하므로 데이터의 조회 및 수정에 있어서 0(1)의 시간에 처리

  data = dict()
  data['사과'] = 'Apple' # 키 : 값
  data['바나나'] = 'Banana'
  datal'코코넛'] = 'Coconut'
  

키 데이터만 담은 리스트

key_list = data.keys()

값 데이터만 담은 리스트

value_list = data.values()

각 키에 따른 값을 하나씩 출력

for key in key_list: print(data[key])

---

# 집합 자료형
- **중복을 허용하지 않음**

- 순서가 없음
- **리스트 혹은 문자열**을 이용해서 초기화 가능
  - `set()` 함수 이용
- 혹은 **중괄호** 안에 각 원소를 콤마(,)를 기준으로 구분하여 삽입함으로써 초기화 가능
- 데이터의 조회 및 수정에 있어서 **O(1)**의 시간에 처리할 수 있습니다.
```py
# 집합 자료형 초기화 방법 1
data = set([1, 1, 2, 3])

# 집합 자료형 초기화 방법 2
data = {1, 1, 2, 3}

# 새로운 원소 추가
data.add(4)

# 새로운 원소 여러 개 추가
data.update([5, 6])

# 특정한 값을 갖는 원소 삭제
data.remove(3)

a = set([1, 2, 3, 4, 5])
b = set([3, 4, 5, 6, 7])

# 합집합
print(a l b)

# 교집합
print(a & b)

# 차집합
print(a - b)

사전 자료형과 집합 자료형의 특징

• 리스트나 튜플은 순서가 있기 때문에 인덱싱을 통해 자료형의 값을 얻을 수 있음

• 사전 자료형과 집합 자료형은 순서가 없기 때문에 인덱싱으로 값을 얻을 수 없음

  • 사전의 키(Key) 혹은 집합의 원소(Element)를 이용해 O(1)의 시간 복잡도로 조회

기본 입출력

자주 사용되는 입력 방법

• input() 함수는 한 줄의 문자열을 입력 받는 함수

• map() 함수는 리스트의 모든 원소에 각각 특정한 함수를 적용할 때 사용

  • ex) 공백을 기준으로 구분된 데이터를 입력 받을 때는 다음과 같이 사용 list(map(int, input().split()))

  • ex) 공백을 기준으로 구분된 데이터의 개수가 많지 않다면, 단순히 다음과 같이 사용 a, b, c = map(int, input().split())

빠르게 입력 받기

• 사용자로부터 입력을 최대한 빠르게 받아야 하는 경우

• 파이썬의 경우 Sys 라이브러리에 정의되어 있는 sys.stdin.readline() 메서드를 이용

  • 단, 입력 후 엔터(Enter)가 줄 바꿈 기호로 입력되므로 rstrip() 메서드를 함께 사용: data = sys.stdin.readline().rstrip()

자주 사용되는 출력 방법

• 자동 줄바꿈을 원하지 않는 경우 print(1, end=" ")

• 정수형을 문자열과 함께 출력하는 경우 print(정답은 + str(answer) + "입니다." or print(f"정답은 {answer}입니다.") (f-string)

조건문과 반복문

조건문

if score >= 90:
    print("학점: A")
elif score >= 80:
    pass # 나중에 작성할 소스코드
else:
    print("학점: F")

💡 in 연산자와 not in 연산자 다수의 데이터를 담는 자료형을 위해 사용한다. 리스트, 튜플, 문자열, 딕셔너리 모두에서 사용 가능

💡 pass 키워드 형태만 만들어놓고 아무것도 처리하고 싶지 않을 때

조건문 편의성 제공

• 조건문 간소화: if ~ else문을 한줄에 작성

  result = "Success" if score ›= 80 else "Fail"

• 다른 언어와는 다르게 수학적 부등식 사용 가능

  if 0 < x < 20:
      print("×는 0 이상 20 미만의 수입니다.")

반복문

• while문

  while i <= 9:
      result += i
      i += 1

• for문

  array = [9, 8, 7, 6, 5]
  for x in array:
      print(x)
  
  # 연속적 값 순회 시 range(시작 값, 끝 값 + 1)
  for i in range(1, 10):
      result += i

  💡 for i in range(1, 11)와 for i in range(10)의 반복 횟수는 동일

함수

def add(a, b):
    print('함수의 결과: ', a + b)

add (3, 7)

# 파라미터의 변수 직접 지정 시 매개변수의 순서 달라도 ok
def add (a, b):
  print('함수의 결과:', a + b)

add(b = 3, a = 7)

global 키워드

함수 내에서 global 키워드로 변수를 지정하면 지역변수를 만들지 않고, 함수 바깥에 선언된 변수를 바로 참조

a = 0

def func():
    global a
    a += 1

for i in range(10):
    func()

print(a)

# 결과: 10

💡 값을 변경하지 않고 단순 참조만 하는 경우, global 키워드 없이 참조 가능

a = 10
def func():
    print(a)
func()
# 결과: 10

💡 전역변수로 선언된 리스트 객체의 내부 메소드도 global 키워드 없이 사용 가능

array = [1, 2, 3, 4, 5]
def func():
    array.append(6)
print(array)
func()
# 결과: [1, 2, 3, 4, 5, 6]

여러 개의 반환 값

파이썬 함수는 여러 개의 반환 값을 가질 수 있음

def operator(a, b):
    add_var = a + b
    subtract_var = a - b
    multiply_var = a * b
    divide_var = a / b
    return add_var, subtract_var, multiply_var, divide_var

a, b, c, d = operator (7, 3)
print(a, b, c, d)

람다 표현식

이름 없는 함수: 함수를 간단하게 작성 가능 사용 방식: print((lambda 지역변수 : return값)(매개변수))

# 일반적인 add() 메서드 사용
def add(a, b):
    return a + b

print(add(3, 7))


# 람다 표현식으로 구현한 add() 메서드
print((lambda a, b: a + b) (3, 7))

내장 함수에서 자주 사용됨. ex) sorted 함수에서 key 속성은 정렬 기준. 함수로 정렬 기준 선언 가능

array = [('홍길동', 50), ('이순신', 32), ('아무개', 74)]

def my_key (x) :
    return x[1]

print(sorted(array, key=my_key))
# x 배열의 두번째 요소, 즉 나이를 기준으로 정렬하겠다. 위와 동일한 작업
print(sorted(array, key=lambda x: x[1]))

여러 개의 리스트에 적용

list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

# a와 b에 대해 a+b를 반환하는 함수 정의(lambda), 이것을 list1과 list2에 적용(map) - 원소를 확인하며 각 위치에 맞는 결과가 담김 
result = map(lambda a, b: a + b, listl, list2)

print(list(result))

실전에서 유용한 표준 라이브러리

자주 사용되는 내장 함수

순열과 조합

itertools의 라이브러리 사용

그 외

느낀 점

쇼킹하다. 내가 C언어로 순열, 조합 구현하느라 얼마나 힘들었는데 🚬🫠 솔직히 강의 들으면서도 '그냥 익숙한 C언어로 알고리즘 풀까...' 싶었지만 1강 듣고 나니 그냥 파이썬에 충성해야겠다는 생각뿐

csv 파일 불러오기

import pandas as pd

df = pd.read_csv("songs.csv", header=None, nrows=1000) # csv 저장할때 header 없이 저장했으므로 읽어들일 때에도 명시 필요
df = df.where(pd.notnull(df), None)

• 엑셀 파일 불러오는 경우 pd.read_excel() 사용
• 파일 내에 column에 대한 헤더가 존재한다면 header=None 삭제 💡 해당 코드 없으면 csv 파일의 첫번째 row를 자동으로 제거해 불러옴

MySql 연동

import pymysql

# DB 정보
host = "localhost"
user = "root"
password = "0000"
database = "songmmelier"

# DB 연결
conn = pymysql.connect(host=host, user=user, password=password, db=database)
curs = conn.cursor(pymysql.cursors.DictCursor)

sql문 작성

# DB delete: 'rank' 컬럼에 값이 있는 모든 데이터 삭제
sql_delete = """DELETE FROM song WHERE `rank` IS NOT NULL;"""
curs.execute(sql_delete)

# DB insert
sql = """insert into song (`rank`, tj_number, title, artist) 
VALUES(%s, %s, %s, %s);""" # 주의: int type이어도 파이썬에서 쿼리 짤 때에는 문자열 자료형(%s)으로 지정

for idx in range(len(df)):
    curs.execute(sql, tuple(df.values[idx]))

conn.commit()

curs.close()
conn.close()

• 코드를 실행할 때마다 song 테이블의 탑100 노래 모두 삭제, 다시 데이터 삽입
• mysql에 'rank' 함수가 존재하므로 rank column 이름 작성 시 따옴표로 묶음 필요
• curs.execute(sql문): sql문 실행
• conn.commit(): 커밋
• curs.close(), conn.close(): 커서 닫기 및 연결 종료

최종 코드

import pymysql.cursors
import requests
from bs4 import BeautifulSoup as bs
import pandas as pd
from concurrent.futures import ThreadPoolExecutor
import csv
import pymysql

# 데이터 크롤링
def fetch_data(url):
    response = requests.get(url)
    # 한글 데이터 안깨지게 가져오려면 인코딩 필요
    response.encoding = 'utf-8'
    html = response.text
    soup = bs(html, 'html.parser')

    # .board_type1>tbody>tr:nth-child(n+2) 선택자를 사용하여 첫 번째 tr을 제외
    items = soup.select(".board_type1>tbody>tr:nth-child(n+2)")
    data = []
    for item in items:
        rank = item.select_one("td:nth-child(1)").text
        number = item.select_one("td:nth-child(2)").text
        title = item.select_one("td:nth-child(3)").text
        artist = item.select_one("td:nth-child(4)").text
        data.append((rank, number, title, artist))
    return data

# 수집할 URL 리스트 생성
urls = ["https://www.tjmedia.com/tjsong/song_monthPopular.asp" for _ in range(10)]  # URL을 10번만 호출하도록 수정

# 동시 요청 수행
data = []
with ThreadPoolExecutor(max_workers=10) as executor:
    results = executor.map(fetch_data, urls)

    for result in results:
        data.extend(result)

# 동시 요청으로 인한 데이터 중복 제거
data = list(set(data))

# 데이터를 DataFrame으로 변환
df = pd.DataFrame(data, columns=["Rank", "Number", "Title", "Artist"])

# DataFrame을 CSV 파일로 저장
df.to_csv("songs.csv", header=False, index=False, quoting=csv.QUOTE_ALL)

print("Data saved successfully to songs.csv")

# DB 정보
host = "localhost"
user = "root"
password = "0308"
database = "songmmelier"

# DB 연결
conn = pymysql.connect(host=host, user=user, password=password, db=database)
curs = conn.cursor(pymysql.cursors.DictCursor)

# DB delete: 'rank' 컬럼에 값이 있는 모든 데이터 삭제
sql_delete = """DELETE FROM song WHERE `rank` IS NOT NULL;"""
curs.execute(sql_delete)

# DB insert
sql = """insert into song (`rank`, tj_number, title, artist) 
VALUES(%s, %s, %s, %s);""" # 주의: int type이어도 파이썬에서 쿼리 짤 때에는 문자열 자료형(%s)으로 지정

for idx in range(len(df)):
    curs.execute(sql, tuple(df.values[idx]))

conn.commit()

curs.close()
conn.close()

print("Data saved successfully to mysql")

• 데이터를 수집하면서 이미 DataFrame이 생성되었으므로 따로 csv 파일을 읽어들이는 부분은 생략

느낀점

• 이전 포스팅에서 각 속성값이 쌍따옴표로 묶여 csv 파일로 저장되었기에 db 저장시 처리 방법을 고민했으나 실제로 db에 들어가는 값은 쌍따옴표 제거되어 들어감 👍

• 겁먹었었는데 나름 간단하게 코드를 완성했다.

• 비상비상...🚨 song 테이블에 기존 노래 데이터 + 노래방 탑100 데이터를 합치려고 했는데 지금 코드로는 원래 순위권에 없던 노래를 song 테이블에 추가 ➡️ 이후 노래방 탑100 진입 ➡️ 새 레코드로 노래 데이터가 추가됨 이런 문제가 있다. 탑100 노래 저장하는 테이블을 분리시켜야 할까?

참조: https://lifesteps.tistory.com/119