운영중인 플러터 앱에 구글 애드몹 광고를 적용하기 위해 google_mobile_ads: ^5.3.1를 설치했다.

광고는 성공적으로 적용했지만 기존 webview를 열면 아래와 같은 오류가 발생하면 앱이 죽는 현상이 발생했다.

Could not cast value of type 'NSNull' (0x1f04621d0) to 'webview_flutter_wkwebview.AuthenticationChallengeResponse'

🕵️ 원인

일단 google_mobile_ads를 설치하고 난 후부터 오류가 발생했으니 해당 패키지를 살표 보기로함.

여기서 보니까 이 패키지는 아래와 같은 의존 패키지가 있음.

그리고 오류 내용을 살펴보면 webview_flutter_wkwebview와 관련 있음.

이후 사례를 찾아보려 구글링 시작. webview_flutter_wkwebview 관련해서 패키지 버전 의존성 문제가 자주 발생하는 것을 인식.

🚀 해결

https://github.com/flutter/flutter/issues/162437#issuecomment-2626546934

위 깃헙 이슈의 토론에서 적합하다고 생각한 방법 선택.

google_mobile_ads: ^5.3.1을 설치하면서 패키지 의존성에 따라 webview_flutter_wkwebview: ^3.18.0로 업그레이드 되었음.

이를 아래와 같이 3.17.0 버전으로 다운그레이드 설정하여 해결 완료. 🎉

# pubspec.yaml
dependency_overrides:
  webview_flutter_wkwebview: 3.17.0

인프런(inflearn)은 2017년 부터 운영중인 온라인 교육 전문 플랫폼이다. 주로 프로그래밍, 개발, 인공지능, 데이터, 디자인과 같은 IT분야 교육을 핵심으로 성장했다. 이외에도 업무 스킬, 영어 등 다양한 분야의 교육을 확장해 나가고 있다.

현재 (주)인프랩에서 운영중이다. 인프랩 실Log에서 인프런의 성장(발전) 기록을 볼 수 있다.

과거에 인프런 모바일 앱을 서비스 했으나 제대로 되지 않아 웹 위주로 사용 되었다. 그래서 중간에 앱 서비스가 중단 되었다가 2024년 6월에 새로운 모바일 앱을 출시 하였다.

주요 경쟁사

• 유데미
• 패스트캠퍼스
• 프로그래머스
• 구름에듀
• 등등

👨‍💻 iOS 앱 분석

인프런 앱 같은 경우는 본인의 강의를 수강하는 목적만 가지고 있다. 그래서 인프런의 다른 서비스(강의 구매 및 검색)는 웹 서비스로 이용해야 한다. 그래서 비교적 앱이 간단하다. (나의 강의를 볼 수 있는 기능만 있음)

학습중 - 1

학습중 - 2

설정

숲(구 아프리카TV)은 스트리머와 유저가 함께 실시간 소통을 통해 함께 콘텐츠를 만들어가는 Live Streaming 서비스 플랫폼이다.

주요 경쟁사

• 네이버 치지직
• 유튜브 라이브
• 트위치 (한국 서비스 철수)

  👨‍💻 iOS 앱 분석

  이번에는 숲의 홈 화면만 분석해 본다.

  홈 - 추천1

  앱을 실행하면 가장 처음에 보이는 화면으로 실시간 인기 방송을 상단에 보여준다.

홈 - 추천2

홈 - 이슈

홈 - 라이브

정보화 시대가 되면서 CPU(중앙처리장치)는 한 번쯤 들어본 익숙한 단어가 되었다. CPU는 컴퓨터에서 두뇌의 역할(연산, 제어)을 담당한다.

CPU에서 아키텍처란

CPU 아키텍처는 명령어 집합(ISA), 데이터 유형, 레지스터, 메모리 계층 및 실행 모델을 포함한 CPU의 기본 설계 및 구성을 말한다. 앞으로 x86, x64 그리고 ARM64이라는 아키텍처를 살펴볼 것이다.

x86

x86 아키텍처는 흔히 32비트 체제의 CPU를 일컫는다. 조금 더 정확하게 하면 x86-IA32(Intel Architecture-32)이며 인텔에 의해 고안된 아키텍처이다. 64비트 CPU가 대중화되기 전에는 대부분 컴퓨터에서 이 32비트 CPU를 사용했다.

이름이 x86인 이유

“왜 x86이라 하지? 32비트니까 x32라 하면 좋지 않을까?” 이런 생각이 들기도 할 것이다.

인텔이 과거에 출시한 32비트 CPU의 이름이 386, 486 등이었다. 즉 ‘~86’으로 끝나는 이름이었고 여기서 공통되는 ‘86’만 뽑아 x86이라 부르게 되었다.

x86-IA16(16비트)가 먼저 출시되었지만 대중에게 거의 보급되지 못하고 IA-32가 출시되었다. 그래서 현재에 x86이라 하면 대게 32비트 아키텍처를 의미한다.

x64(amd64)

x86 즉 32비트에서 더 발전되어 64비트 체제의 CPU이다. 64비트가 되어 바뀌는 것은 CPU가 한 번에 처리할 수 있는 데이터의 크기(레지스터 크기)이다.

• 32-bit: 32비트로 데이터를 처리할 수 있으며 최대 4GB RAM을 사용할 수 있다.
• 64-bit: 64비트로 데이터를 처리할 수 있으며 최대 18EB(1.8e+10GB) RAM을 사용할 수 있다.

64비트 도입 초기에는 AMD가 intel 보다 도입하여 amd64라고 불리었다. 추후 intel도 64비트를 도입 함에 따라 x64라고 통칭하게 되었다.

x64 == amd64 // true

ARM64

ARM64는 ARM이라는 회사에서 개발한 64비트 CPU 아키텍처이다. x64와 같은 64비트 아키텍처이지만 x64와 다른 목적을 가지고 탄생한 아키텍처이다. x64는 주로 일반적인 데스크탑 및 노트북에 사용되지만, ARM64는 주로 모바일 기기나 임베디드 컴퓨터와 같은 저전력 컴퓨팅 환경에 사용된다.

즉, intel과 amd와는 목표가 달랐고 근본적으로 다른 CPU 아키텍처이기 때문에 x64와 ARM64는 서로 호환되지 않는다.

근본적으로 다른 이유 중 하나는 x64와 ARM64는 서로 다른 ISA(명령어 집합)를 사용하기 때문이다.

ISA(Instruction Set Architecture)란 하드웨어와 소프트웨어 사이의 인터페이스 역할을 하는 설계도(blueprint)이다. 쉽게 말하면 소프트웨어가 CPU를 제어하는 방법을 설명하는 모델이다.

흔히 들어본 애플의 A 시리즈, M 시리즈, 퀄컴의 스냅드래곤, 삼성의 엑시노스 모두 arm 아키텍처를 따른다.

정리

출처 : https://m.blog.naver.com/cjs0308cjs/223242935705

Reference

• [x86, x64(amd64), Arm64] 뜻, 구분방법, CPU 역사, 차이점 알아보기
• x86과 x64의 뜻과 차이 - CPU, OS, S/W

🚀 나의 접근 방법

이 문제는 브루트포스, 시뮬레이션, 백트래킹 관련 문제이다. 즉, 탐색을 통해 모든 경우의 수를 탐색하게 된다.

중요한 것 중 하나가 탐색에 필요한 인접 행렬을 정의하는 것이다. 문제에서 주어진 그래프가 복잡하기 때문에 꼼꼼하게 정의해야 한다.

한 가지 특징이 있다면 중간에 파란색 화살표로 분기가 가능하다는 것이다. 부분은 두 개의 방향을 하나의 리스트로 묶되 1번 인덱스는 출발 시 노드로 정의했다.

DFS로 탐색했으며 말을 하나씩 이동시켜보며 모든 경우의 수를 탐색하여 점수의 최댓값을 구했다.

✍️ 나의 코드

Swift

let adj = [[1],[2],[3],[4],[5],[6,21],[7],[8],[9],[10],[11,27],[12],[13],[14],[15],[16,29],[17],[18],[19],[20],[32],[22],[23],[24],[25],[26],[20],[28],[24],[30],[31],[24],[32],[32],[32],[32],[32]]
let score = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18,  20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 13, 16, 19, 25, 30, 35, 22, 24, 28, 27, 26, 0]

func dfs(_ n: Int, _ sum: Int) {
    if n == 10 {
        ans = max(ans, sum)
        return
    }

    for j in 0..<4 {
        let s = v[j]
        var c = adj[s].last!
        for _ in 1..<list[n] {
            c = adj[c].first!
        }

        if c == 32 || !v.contains(c) {
            v[j] = c
            dfs(n+1, sum+score[c])
            v[j] = s
        }
    }
}

let list = readLine()!.split(separator: " ").map{ Int($0)! }
var v = [0, 0, 0, 0]
var ans = 0
dfs(0, 0)
print(ans)

🤔 회고

풀이를 생각하기 어려운 문제였다. 꼭 다시 한 번 풀어보자. 참고 - [삼성기출 #33] 17825. 주사위 윷놀이 (백준, 파이썬)

🚀 나의 접근 방법

단순히 주어진 요구사항을 구현하는 문제이다.

효율적인 날짜 계산 방법만 떠올리면 어렵지 않게 해결할 수 있다.

이번에는 날짜를 모두 '일'로 변환하여 계산했다.

년*12*28 + 월*28 + 일

이렇게 변환하면 간단하게 대소 비교로 각 날짜를 비교할 수 있다.

✍️ 나의 코드

Swift

import Foundation

func solution(_ today:String, _ terms:[String], _ privacies:[String]) -> [Int] {
    func dateToInt(_ date: String) -> Int {
        let temp = date.split(separator: ".").map{ Int($0)! }
        return temp[0]*12*28 + temp[1]*28 + temp[2]
    }

    let todayDate = dateToInt(today)
    var termsDic: [String:Int] = [:]
    for term in terms {
        let input = term.split(separator: " ")
        termsDic[String(input[0])] = Int(input[1])! * 28
    }

    var result: [Int] = []
    for (i, privacie) in privacies.enumerated() {
        let input = privacie.split(separator: " ").map{ String($0) }
        let (collectionDate, type) = (dateToInt(input[0]), input[1])
        if collectionDate + termsDic[type]! <= todayDate {
            result.append(i+1)
        }
    }
    return result
}

🤔 회고

개선 전 코드

개선 전에는 아래와 같이 날짜 연, 월, 일을 따로 계산했다. 그러다 보니 계산이 복잡해지고 코드가 불필요하게 복잡해졌다. 알고리즘 문제에서 날짜 계산이 나오면 하나의 단위로 변환하는 것을 먼저 고려해 보자!

import Foundation

func solution(_ today:String, _ terms:[String], _ privacies:[String]) -> [Int] {
    func dateStringToIntArray(_ date: String) -> [Int] {
        return date.split(separator: ".").map{ Int($0)! }
    }

    let todays = dateStringToIntArray(today)
    var termss: [String:Int] = [:]
    for term in terms {
        let input = term.split(separator: " ")
        termss[String(input[0])] = Int(input[1])!
    }

    func calculateDate(_ date: [Int], _ add: Int) -> [Int] {
        var newDate = Array(repeating: 0, count: 3)
        let addY = add/12
        let addM = add%12
        newDate[0] = date[0] + addY
        newDate[1] = date[1] + addM
        newDate[2] = date[2] - 1

        if newDate[1] > 12 {
            newDate[0] = newDate[0] + 1
            newDate[1] -= 12
        }
        if newDate[2] < 1 {
            newDate[1] = newDate[1] - 1
            if newDate[1] == 0 {
                newDate[1] = 12
            }
            newDate[2] = 28
        }
        return newDate
    }

    func isDateOver(_ today: [Int], _ past: [Int], _ type: String) -> Bool {
        let date = calculateDate(past, termss[type]!)
        if date[0] < today[0] { return true }
        else if date[0] == today[0] && date[1] < today[1] { return true }
        else if date[0] == today[0] && date[1] == today[1] && date[2] < today[2] { return true }
        else { return false }
    }

    var result: [Int] = []
    for (i, privacie) in privacies.enumerated() {
        let input = privacie.split(separator: " ").map{ String($0) }
        let (past, type) = (dateStringToIntArray(input[0]), input[1])
        if isDateOver(todays, past, type) {
            result.append(i+1)
        }
    }
    return result
}

🚀 나의 접근 방법

특별히 문제를 해결하는 알고리즘은 없다. 단순히 주어진 요구사항을 구현하는 문제이다.

1 ~ 7단계 요구사항을 하나씩 구현해 주면 된다.

이때 문자열 또는 배열을 활용해야기 때문에 각자 사용 언어의 문법이 중요하다.

Swift 경우에는 아래와 같은 문법을 숙지하고 있다면 쉽게 해결할 수 있을 것이다.

• lowercased()
• isLetter
• isNumber
• contains(_:)
• replacingOccurrences(of:with:)
• hasPrefix(_:)
• hasSuffix(_:)
• removeLast()
• joined(separator:)

✍️ 나의 코드

Swift

import Foundation

func solution(_ new_id:String) -> String {
    var id = new_id
    var newId = ""

    // 1단계 : new_id의 모든 대문자를 대응되는 소문자로 치환합니다.
    id = id.lowercased()

    // 2단계 : new_id에서 알파벳 소문자, 숫자, 빼기(-), 밑줄(_), 마침표(.)를 제외한 모든 문자를 제거합니다.
    for i in id {
        if i.isLetter || i.isNumber || i == "-" || i == "_" || i == "." {
            newId.append(i)
        }
    }

    // 3단계 : new_id에서 마침표(.)가 2번 이상 연속된 부분을 하나의 마침표(.)로 치환합니다.
    while newId.contains("..") {
        newId = newId.replacingOccurrences(of: "..", with: ".")
    }

    // 4단계 : new_id에서 마침표(.)가 처음이나 끝에 위치한다면 제거합니다.
    while newId.hasPrefix(".") {
        newId.removeFirst()
    }

    while newId.hasSuffix(".") {
        newId.removeLast()
    }

    // 5단계 new_id가 빈 문자열이라면, new_id에 "a"를 대입합니다.
    if newId.count == 0 {
        newId = "a"
    }

    // 6단계 new_id의 길이가 16자 이상이면, new_id의 첫 15개의 문자를 제외한 나머지 문자들을 모두 제거합니다. 만약 제거 후 마침표(.)가 new_id의 끝에 위치한다면 끝에 위치한 마침표(.) 문자를 제거합니다.
    if newId.count >= 16 {
        newId = Array(newId.map{String($0)})[0..<15].joined()
    }
    if newId.hasSuffix(".") {
        newId.removeLast()
    }

    // 7단계 new_id의 길이가 2자 이하라면, new_id의 마지막 문자를 new_id의 길이가 3이 될 때까지 반복해서 끝에 붙입니다.
    while newId.count < 3 {
        newId.append(newId.last!)
    }

    return newId
}

🤔 회고

처음 보면 문제의 긴 글에 당황할 수 있지만 차근차근 해결하면 충분히 해결할 수 있다.

🚀 나의 접근 방법

이 문제는 가장 긴 증가하는 부분 수열 문제의 활용이라 보면 된다. 이 문제를 안 풀어 봤다면 먼저 풀어보고 오는 것을 추천한다.

위 문제를 해결하고 왔다면 DP(다이나믹 프로그래밍)를 활용해 가장 긴 증가하는 부분 수열 찾을 수 있을 것이다.

이 문제의 핵심 해결 아이디어는 오름 차순으로 증가하는 부분과 내림차순으로 감소하는 부분을 따로 구해 합하는 것이다.

Int 배열 upCache, downCache를 정의한다.

upCache에 가장 긴 증가하는 부분 수열의 DP 테이블을 저장한다. 그리고 downCache에 가장 긴 감소하는 부분 수열의 DP 테이블을 저장하면 되는데, 필자는 입력되는 배열 A를 reverse 해서 가장 긴 증가하는 부분 수열의 DP 테이블을 구하고 테이블을 reverse 했다.

upCache와 downCache의 각 인덱스를 더하면 증가하는 바이토닉 부분 수열의 dp 테이블을 얻을 수 있다. 이 테이블에서 max 값이 답이 된다.

✍️ 나의 코드

Swift

let N = Int(readLine()!)!
var A = readLine()!.split(separator: " ").map{ Int($0)! }

func dp(array: [Int]) -> [Int] {
    var cache = Array(repeating: 1, count: N)
    for i in 0..<N {
        for j in 0..<i {
            if array[i] > array[j] {
                cache[i] = max(cache[i], cache[j] + 1)
            }
        }
    }
    return cache
}

var upCache = dp(array: A)
A.reverse()
var downCache = dp(array: A)
downCache.reverse()

var maxResult = 0
for i in 0..<N {
    maxResult = max(maxResult, upCache[i] + downCache[i] - 1)
}
print(maxResult)

Python

N = int(input())
A = list(map(int, input().split()))

def dp(array):
    cache = [1] * N
    for i in range(N):
        for j in range(i):
            if A[i] > A[j]:
                cache[i] = max(cache[i], cache[j] + 1)
    return cache

upCache = dp(A)
A.reverse()
downCache = dp(A)
downCache.reverse()

maxResult = 0
for i in range(N):
    maxResult = max(maxResult, upCache[i] + downCache[i] - 1)
print(maxResult)

🤔 회고

이전에 연습했던 문제를 통해 아무 도움 없이 문제를 해결할 수 있었다!! 역시 차근차근 문제를 해결해 나가니 성장하는 것 같다. 앞으로도 파이팅!!

🚀 나의 접근 방법

이 문제는 결국 가장 긴 증가하는 부분 수열 찾기이다!

이미 오름 차순으로 정렬된 번호는 그대로 두고 나머지 번호들을 옮기면 된다.

그래서 가장 긴 증가하는 부분 수열의 길이를 찾아 N에서 빼주면 답이 된다.

✍️ 나의 코드

Swift

let N = Int(readLine()!)!
var people: [Int] = []
for _ in 0..<N {
    people.append(Int(readLine()!)!)
}

var dp: [Int] = Array(repeating: 1, count: N)
for i in 0..<N {
    for j in 0..<i {
        if people[i] > people[j] {
            dp[i] = max(dp[i], dp[j] + 1)
        }
    }
}

print(N - dp.max()!)

Python

N = int(input())
people = []
for _ in range(N):
    people.append(int(input()))

dp = [1] * N
for i in range(N):
    for j in range(i):
        if people[i] > people[j]:
            dp[i] = max(dp[i], dp[j] + 1)

print(N - max(dp))

🤔 회고

핵심만 캐치 했으면 아주 쉽게 해결할 수 있는 문제였다. 하지만 빠르게 캐치하지 못해서 아쉽다. 더 많은 문제를 경험해 보자!

🚀 나의 접근 방법

지금 상자에 앞(왼쪽)에 상자들이 몇 개 들어올 수 있는지 확인하면 된다.

하지만 그냥 계산하면 중복 연산이 많기 때문에 DP(다이나믹 프로그래밍)을 사용한다.

dp 테이블을 정의하고 상자를 차례로 접근한다. 현재 접근 중인 상자 앞(왼쪽)에 현재 상자 크기 보다 작은게 있다면 그 상자(작은 상자)의 dp 값에 1을 더한다.

앞에 작은 상자가 여개 일 수도 있으니 모두 같은 연산을 하고 그중 최댓값을 현재 dp에 저장한다.

그리고 dp 테이블에서 최댓값을 찾으면 답이 된다.

✍️ 나의 코드

Swift

let N = Int(readLine()!)!
let nums = readLine()!.split(separator: " ").map{ Int($0)! }

var dp: [Int] = Array(repeating: 0, count: N)
for i in stride(from: 0, to: N, by: 1) {
    var max = 1
    for j in stride(from: 0, to: i, by: 1) {
        if nums[i] > nums[j] {
            let num = dp[j]+1
            if max < num { max = num }
        }
    }
    dp[i] = max
}

print(dp.max()!)

Python

n = int(input())
nums = list(map(int, input().split(" ")))

dp = [0] * n
for i in range(n):
    maxNum = 1
    for j in range(0, i):
        if nums[i] > nums[j]:
            num = dp[j] + 1
            if num > maxNum: maxNum = num
    dp[i] = maxNum

print(max(dp))

🤔 회고

오늘도 해결하기 쉬운 문제가 나왔다.

🚀 나의 접근 방법

P(1)부터 P(10)까지 첫 10개 숫자 1, 1, 1, 2, 2, 3, 4, 5, 7, 9 에서 점화식을 찾으면 매우 쉽게 해결할 수 있다.

유심히 봐보면 다음과 같은 점화식을 만들 수 있다. P(N) = P(N-2) + P(N-2)

위 점화식으로 dp 테이블을 채우고 테스트 케이스를 출력하면 된다.

✍️ 나의 코드

Swift

let N = Int(readLine()!)!
var dp = [1, 1, 1, 2, 2, 3, 4, 5, 7, 9] + Array(repeating: 0, count: 90)

for i in stride(from: 10, to: 100, by: 1) {
    dp[i] = dp[i-2] + dp[i-3]
}

for _ in 0..<N {
    print(dp[Int(readLine()!)!-1])
}

Python

N = int(input())
dp = [1, 1, 1, 2, 2, 3, 4, 5, 7, 9] + [0] * 90

for i in range(10, 100):
    dp[i] = dp[i-2] + dp[i-3]

for _ in range(N):
    print(dp[int(input())-1])

🤔 회고

오늘은 해결하기 쉬운 문제가 나왔다.

🚀 나의 접근 방법

수열을 순서대로 방문해서 방문 중인 수 기준으로 왼쪽에 있는 수들 중 본인보다 작은 수의 dp 테이블 값에 본인 값(방문 중인 수)을 더해 본인 순서 dp 테이블에 저장하면 된다.

방문 중인 수 왼쪽에 작은 수가 여러 개 있으면 합이 가장 큰 것을 dp 테이블에 저장하면 된다.

그리고 dp 테이블에서 최댓값을 출력하면 된다.

✍️ 나의 코드

Swift

let N = Int(readLine()!)!
let nums = readLine()!.split(separator: " ").map{ Int($0)! }

var dp = nums
for i in 0..<N {
    for j in 0..<i {
        if nums[j] < nums[i] {
            dp[i] = max(dp[i], dp[j]+nums[i])
        }
    }
}

print(dp.max()!)

Python

N = int(input())
nums = list(map(int, input().split(" ")))

dp = [] + nums
for i in range(N):
    for j in range(0, i):
        if nums[j] < nums[i]:
            dp[i] = max(dp[i], dp[j]+nums[i])

print(max(dp))

🤔 회고

DP는 문제 풀이에 비해 설명하는 것이 어려운 것 같다. 누군가에게 알려준다고 생각하듯이 연습하자!

🚀 나의 접근 방법

수열에서 i번째 수 보다 0~(i-1)번째 수에서 더 큰 값이 있다면 해당 수의 부분 수열의 길이에 +1 해주면 된다.

DP 테이블을 N 길이 만큼 1로 초기화 한다. 1로 초기화 하는 이유는 부분 수열의 초소 길이가 자기 자신 1개이기 때문이다.

✍️ 나의 코드

Swift

let N = Int(readLine()!)!
var nums = readLine()!.split(separator: " ").map{ Int($0)! }

var dp = Array(repeating: 1, count: N)
for i in 0..<N {
    for j in 0..<i {
        if nums[i] < nums[j] {
            dp[i] = max(dp[i], dp[j]+1)
        }
    }
}

print(dp.max()!)

🤔 회고

어렵진 않은 문제인데 뭔가 기존에 풀었던 DP문제와 조금 달라 빠르게 풀지 못 했다. 조금 더 다양한 문제를 풀어보자.

🚀 나의 접근 방법

규칙만 찾으면 매우 간단한 문제이다.

두 가지 방법으로 해결할 수 있다.

방법 1 : 홀수짝수

직접 주어진 규칙에 따라 이기는 사람을 찾아보면 N이 홀수일 때는 상근이가, 짝수일 때는 창영이가 이기는 것을 알 수 있다.

방법 2 : DP

DP의 점화식은 dp[N] = dp[N-3] 또는 dp[N-1]의 반대 이다. 아래 예제로 살펴보자.

N이 4일 때 dp[4]의 값은 dp[3]과 dp[1]의 반대 값이다.

N이 5일 때 dp[5]의 값은 dp[4]과 dp[2]의 반대 값이다.

위 예제는 돌을 1개씩 가져간 경우이지만 3개씩 가져간 경우도 해보면 동일한 규칙이다.

그래서 아래와 같이 두 가지 방법으로 문제를 해결할 수 있다.

✍️ 나의 코드

Swift

// 방법 1 : 홀짝
Int(readLine()!)!%2 == 0 ? print("CY") : print("SK")

// 방법 2 : DP
let N = Int(readLine()!)!

var dp = Array(repeating: 0, count: 1000)
dp[0] = 1
dp[1] = 2
dp[2] = 1

if N > 2 {
    for i in 3..<N {
        if dp[i-1] == 1 || dp[i-3] == 1 { dp[i] = 2 }
        else { dp[i] = 1 }
    }
}

dp[N-1] == 1 ? print("SK") : print("CY")

Python

# 방법 1 : 홀짝
print("CY") if int(input())%2 == 0 else print("SK")

# 방법 2 : DP
N = int(input())

dp = [0] * 1000
dp[0] = 1
dp[1] = 2
dp[2] = 1

for i in range(3, N):
    if dp[i-1] == 1 or dp[i-3] == 1: dp[i] = 2
    else: dp[i] = 1

print("SK") if dp[N-1] == 1 else print("CY")

🤔 회고

Python 삼항 연산자

[참일때] if [조건문] else [거짓일때]

파이썬의 삼항 연산자는 위와 같은 형태이다. 보편적인 [조건문] ? [참일때] : [거짓일때] 형태와 다르다. 잘 기억해두자.

🚀 나의 접근 방법

이 문제를 처음 읽어보면 움칫한다. (어떻게 하라는 걸까?)

특별한 것은 없다. 완전탐색(브루트포스)로 모든 경우의 수를 확인하면 된다.

가장 중요한 것은 1번(가장 아래) 주사위이다. 그래서 1번 주사위의 모든 각 면이 바닥을 향할 때 규칙에 맞게 주사위를 쌓고 기둥 한 면의 최댓값을 구하면 된다.

[5개 주사위 예제]

1. 1번 주사위의 0번 인덱스 숫자를 바닥면으로 정한다.
2. 1번 주사위의 윗면 숫자를 구한다.
3. 1번 주사위의 사이드(바닥,위면 제외) 숫자들을 구해 sides 배열 저장한다. (반복문 2번~5번 주사위)
4. 2번 주사위의 바닥 숫자는 1번 주사위의 윗면 숫자이다.
5. 2번 주사위의 윗면 숫자를 구한다.
6. 2번 주사위의 사이드 숫자들을 구해 sides 배열에 저장한다. (3~5번 주사위도 위와 같이 반복하여 사이드 숫자들을 구한다)

그러면 sides에는 [1번 주사위 사이드, 2번 주사위 사이드, 3번 주사위 사이드 ...]가 저장 된다.

이제 각 주사위 사이드에서 최대값을 골라낸다. [1번 사이드 최대값, 2번 사이드 최대값, 3번 사이드 최대값 ...] 이를 모두 더하면 답이 된다!!

✍️ 나의 코드

Swift

let N = Int(readLine()!)!

var dices: [[Int]] = []
for _ in 0..<N {
    dices.append(readLine()!.split(separator: " ").map{ Int($0)! })
}

// 주사위의 반대편 숫자를 구하는 함수
func getOppositeNum(currentNum: Int, dice: [Int]) -> Int {
    let idx = dice.firstIndex(of: currentNum)
    switch idx {
    case 0: return dice[5]
    case 1: return dice[3]
    case 2: return dice[4]
    case 3: return dice[1]
    case 4: return dice[2]
    case 5: return dice[0]
    default: return 0
    }
}

// 주사위에서 밑면, 위면을 제외한 사이드 숫자들을 구하는 함수
func getSideNums(bottomNum: Int, upperNum: Int, dice: [Int]) -> [Int] {
    var pDice = dice
    pDice.remove(at: pDice.firstIndex(of: bottomNum)!)
    pDice.remove(at: pDice.firstIndex(of: upperNum)!)
    return pDice
}

var result: [Int] = []
for i in 0..<6 {
    var sides: [[Int]] = []
    var bottomNum = dices[0][i]
    var upperNum = getOppositeNum(currentNum: bottomNum, dice: dices[0])
    sides.append(getSideNums(bottomNum: bottomNum, upperNum: upperNum, dice: dices[0]))

    for j in 1..<N {
        bottomNum = upperNum
        upperNum = getOppositeNum(currentNum: bottomNum, dice: dices[j])
        sides.append(getSideNums(bottomNum: bottomNum, upperNum: upperNum, dice: dices[j]))
    }
    result.append(sides.map{ $0.max()! }.reduce(0, +))
}

print(result.max()!)

🤔 회고

처음에는 복잡해 보여 당황했지만 규칙에 맞게 해보니 생각하는 데로 풀렸다. 당황하지 말고 성실하게 풀자!!

🚀 나의 접근 방법

아이디어는 간단하다. 직접 전선을 하나씩 끊어 보면서 두 전력망의 송전탑 개수의 차이를 구하면 된다. 즉, 완전탐색이다.

전선(간선)을 하나씩 제거하기 위해 wires 요소들을 순서대로 한 개씩 제거하고 (두 개의 전력망을 가진) 그래프로 만들었다. 그리고 그 그래프를 DFS를 통해 탐색하여 두 전력망의 송전탑 개수의 차이를 구했다.

이후 송전탑 개수의 차이 중에 최소를 반환하면 된다!

✍️ 나의 코드

Swift

import Foundation

func solution(_ n:Int, _ wires:[[Int]]) -> Int {    
    var result: [Int] = []
    for i in 0..<(n-1) {
        // 간선을 하나 제거하고 그래프를 만든다(전선 끊기)
        var graph: [[Int]] = Array(repeating: [], count: n+1)
        for (j, wire) in wires.enumerated() {
            if i == j { continue }
            graph[wire[0]].append(wire[1])
            graph[wire[1]].append(wire[0])
        }

        // DFS로 연결된 송전탐의 개수를 구한다
        var visited = Array(repeating: false, count: n+1)
        func dfs(_ v: Int, _ count: Int) -> Int {
            visited[v] = true
            var nCount = count+1
            for k in graph[v] {
                if !visited[k] {
                    nCount = dfs(k, nCount)
                }
            }
            return nCount
        }

        // 그래프를 탐색한다
        // 간선(전선)을 하나 끊었으므로 counts에는 2개가 추가 된다
        var counts: [Int] = []
        for t in 1...n {
            if !visited[t] {
                counts.append(dfs(t, 0))
            }
        }
        result.append(abs(counts[0]-counts[1]))
    }
    return result.min()!
}

🤔 회고

처음에는 복잡해 보여 당황했지만 막상 해보니 생각하는 데로 바로 풀렸다. 다만 코드가 길어지다 보니 인덱스 범위 실수가 잦았다. 더 집중해서 신속하게 풀어보자!

🚀 나의 접근 방법

숫자 종이 개수가 최대 7로 경우의 수가 많지 않아 완전탐색으로 진행했다.

DFS로 숫자 종이로 만들 수 있는 숫자의 모든 경우를 탐색했다. 탐색하면서 해당 숫자가 소수인지를 확인하여 result Set 자료형(중복이 있기 때문)에 담았다.

소수를 판별하는 함수를 직접 구현해야 한다. 가장 기본적인 방법으로 구현했다. (O(N))

결국 result에 담긴 요소의 개수가 답이 된다.

✍️ 나의 코드

Swift

import Foundation

func solution(_ numbers:String) -> Int {
    let nums = numbers.map{ String($0) }

    func isPrimeNum(_ n: [String]) -> Bool {
        guard let num = Int(n.joined()) else { return false }
        if num <= 1 { return false }
        if num <= 3 { return true }
        if num % 2 == 0 { return false }
        for i in 2..<sqrt(num) {
            if num % i == 0 { return false }
        }
        return true
    }

    var result: Set<Int> = []
    var visited = Array(repeating: false, count: nums.count)

    func dfs(_ nnum: [String]) {
        for (i, num) in nums.enumerated() {
            if nnum.isEmpty && num == "0" { continue }
            var newNum = nnum + [num]
            if !visited[i] {
                visited[i] = true
                if isPrimeNum(newNum) {
                    result.insert(Int(newNum.joined())!)
                }
                dfs(newNum)
                visited[i] = false
            }
        }
    }
    dfs([])
    return result.count
}

🤔 회고

소수(Prime Number) 판별

이번에는 가장 기본적인 소수 판별 알고리즘을 사용했다. 하지만 O(N)으로 판발하려는 숫자가 클수록 비효율적이다.

그래서 에라토스테네스의 체와 같은 알고리즘이 존재한다. 시간초과를 대비하여 학습해 두자.

참고 : 어떤 수가 소수(Prime Number)인지 아닌지 판별하는 다양한 알고리즘

🚀 나의 접근 방법

던전의 개수가 최대 8로 경우의 수가 많지 않고 특별한 규칙이 없기 때문에 완전탐색으로 할만하다.

DFS로 탐색했으며 탐색하면서 피로도를 계산하여 던전을 탐험할 수 있는지 확인하고 탐험한 최대 던전 수를 구하면 된다.

✍️ 나의 코드

Swift

import Foundation

func solution(_ k:Int, _ dungeons:[[Int]]) -> Int {
    var visited = Array(repeating: false, count: dungeons.count)
    func dfs(_ k: Int, _ count: Int, _ maxCount: Int) -> Int {
        var mc = maxCount
        for (i, dungeon) in dungeons.enumerated() {
            if !visited[i] && k >= dungeon[0] {
                visited[i] = true
                mc = dfs(k-dungeon[1], count+1, mc)
                visited[i] = false
            } 
        }
        return max(mc, count)
    }
    return dfs(k, 0, 0)
}

🤔

🚀 나의 접근 방법

완전탐색으로 카펫의 최소 높이(3)부터 1씩 증가시키면서 yellow 개수가 실제 개수와 일치할 때까지 탐색한다.

yellow는 1이상이므로 카펫의 전체 높이는 3 이상이다. 그래서 초기 height를 3으로 정의한다. 카펫의 width는 (brown + yellow)/height로 계산할 수 있다.

반복문을 돌면서 yellow 개수를 구하고((width-2) * (height-2)) 일치하다면 반복문 종료, 아니면 높이를 1 증가시키고 width를 다시 계산한다.

이 과정을 반복하면 답을 구할 수 있다. 즉, 카펫의 최소 높이부터 격자의 개수를 계산하며 탐색하는 것이다.

✍️ 나의 코드

Swift

import Foundation

func solution(_ brown:Int, _ yellow:Int) -> [Int] {
    var height = 3
    var width =  (brown + yellow)/height
    while true {
        if (width-2) * (height-2) == yellow { break }
        height += 1
        width = (brown + yellow)/height
    }
    return [width, height]
}

Python

def solution(brown, yellow):
    height = 3
    width = (brown+yellow)/height
    while True:
        if (width-2) * (height-2) == yellow: break
        height += 1
        width = (brown+yellow)/height

    return [width, height]

🤔 회고

첫 시도의 반례

처음에는 아래와 같이 풀이했다. 기본 테스트 케이스는 통과했지만 제출 채점은 통과할 수 없었다.

def solution(brown, yellow):
    yellowX = yellow
    yellowY = 1
    while yellowX >= yellowY:
        if yellowX*2 + yellowY*2 + 4 == brown:
            break
        else:
            yellowX /= 2
            yellowY *= 2

    return [yellowX+2, yellowY+2]

이것에 대한 반례로 Parameters(brown: 24, yellow: 25), Return([7, 7])가 있다. 즉, 위의 코드는 높이가 짝수인 경우만 탐색하므로 답을 찾을 수 없다.

반례를 찾고 생각하며 문제를 해결해 보자.

🚀 나의 접근 방법

다 탐색을 하는 거라 특별한 알고리즘은 없다. 얼마나 간결하게 코드를 작성하느냐가 중요하다.

1번 수포자가 찍는 방식 : 1, 2, 3, 4, 5 ... 반복 (5개) 2번 수포자가 찍는 방식 : 2, 1, 2, 3, 2, 4, 2, 5 ... 반복 (8개) 3번 수포자가 찍는 방식 : 3, 3, 1, 1, 2, 2, 4, 4, 5, 5 ... 반복 (10개)

문제 정답(answers)이 리스트로 주어졌다. 그리고 answers의 각 index로 index%(반복되는 답 개수)를 계산하여 각 수포자가 찍는 답을 알 수 있다. ⬇️ 예시

pick = [
        [1, 2, 3, 4, 5],
        [2, 1, 2, 3, 2, 4, 2, 5],
        [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
    ]
for i, answer in enumerate(answers):
    if answer == pick[0][i%5]: result[0][1] += 1
    if answer == pick[1][i%8]: result[1][1] += 1
    if answer == pick[2][i%10]: result[2][1] += 1

그리고 조건에 맞게 가장 많은 문제를 맞힌 사람을 return하면 된다.

✍️ 나의 코드

Swift

import Foundation

func solution(_ answers:[Int]) -> [Int] {
    let pick = [
        [1, 2, 3, 4, 5],
        [2, 1, 2, 3, 2, 4, 2, 5],
        [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
    ]

    var result: [(Int, Int)] = [(1, 0), (2, 0), (3, 0)]
    for (j, ans) in answers.enumerated() {
        if ans == pick[0][j%5] { result[0].1 += 1 }
        if ans == pick[1][j%8] { result[1].1 += 1 }
        if ans == pick[2][j%10] { result[2].1 += 1 }
    }

    return result.filter{$0.1 == result.max{$0.1 < $1.1}!.1}.map{$0.0}
}

Python

def solution(answers):
    pick = [
        [1, 2, 3, 4, 5],
        [2, 1, 2, 3, 2, 4, 2, 5],
        [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
    ]

    result = [[1, 0], [2, 0], [3, 0]]
    for i, answer in enumerate(answers):
        if answer == pick[0][i%5]: result[0][1] += 1
        if answer == pick[1][i%8]: result[1][1] += 1
        if answer == pick[2][i%10]: result[2][1] += 1

    return list(map(lambda item: item[0], list(filter(lambda item: item[1] == max(result, key=lambda item: item[1])[1], result))))

🤔 회고

고차함수 남용

python 마지막 줄을 보면 고차함수가 매우 복잡하게 섞여있다. 저 정도면 그냥 반복문으로 하는것이 더욱 가독성이 좋을것 같다.

Swift와 Python에서 Tuple의 차이점

• swift 튜플의 요솟값은 변화 가능하다.
• python 튜플의 요솟값은 변화가 불가능하다.