boraBong

[Swift] 5430번: AC 문제 풀이 [BOJ - Gold5]

보라봉_ — Fri, 21 Apr 2023 04:20:50 +0900

문제

https://www.acmicpc.net/problem/5430

5430번: AC

각 테스트 케이스에 대해서, 입력으로 주어진 정수 배열에 함수를 수행한 결과를 출력한다. 만약, 에러가 발생한 경우에는 error를 출력한다.

www.acmicpc.net

Idea

함수 수행시 R이 나올 때마다 reverse를 수행하고, D가 나올 때마다 removeFirst()를 수행해주었더니 시간 초과가 발생했다.
따라서 투포인터 방식을 활용해서 풀이해주었다.
- R을 수행할 차례라면 isReverse flag를 변경해준다
- D를 수행할 차례라면
  1. pointer가 reversepointer보다 크다면 → error인 경우이므로 error를 출력하고 continue문을 수행시킨다. (-> labeled로 인해 중첩 for문 같이 영향)
  2. isReversed flag 상태라면 → reversepointer를 좁혀준다.
  3. isReversed flag 상태가 아니라면 → pointer 범위를 늘려준다.
- RD 함수 종료 후
  - pointer가 reversepointer보다 크다면 빈 배열을 의미하므로 []를 출력한다.
  - 그렇지 않다면 pointer부터 reversepointer까지 배열을 slice한 후 출력 조건에 맞게 배열을 맵핑한 뒤 출력한다.
    - (배열 자체를 출력할 경우 [1,2,3] 과 같이 출력되지 않고 [1, 2, 3] 과 같이 출력되므로 답이 틀리다고 나오므로 주의하자.)

풀이

import Foundation

func solution5430() {
    let t = Int(readLine()!)!
    
outloop: for _ in 0..<t {
        let function = readLine()!
        let n = Int(readLine()!)!
        let arr = readLine()!.trimmingCharacters(in: ["[", "]"]).split(separator: ",").map({ Int(String($0))! })
        var pointer = 0
        var reversepointer = n - 1
        var isReverse = false
    
        for i in function {
            if i == "R" {
                isReverse = !isReverse
            } else {
                if pointer > reversepointer {
                    print("error")
                    continue outloop
                }
                
                if isReverse {
                    reversepointer -= 1
                } else {
                    pointer += 1
                }
            }
        }
        
        if pointer > reversepointer {
            print("[]")
        } else {
            var ans = arr[pointer...reversepointer]
            if isReverse {
                ans.reverse()
            }
            print("[" + ans.map({ String($0) }).joined(separator: ",") + "]")
        }
    }
}

알게된 문법

for문에 레이블을 붙여 사용하면 중첩 for문도 한꺼번에 탈출이 가능하다.

https://github.com/hwangJi-dev/swiftAlgorithm/blob/main/Programmers/Boj/5430_AC.swift

GitHub - hwangJi-dev/swiftAlgorithm: Algorithm Practice with Swift

Algorithm Practice with Swift. Contribute to hwangJi-dev/swiftAlgorithm development by creating an account on GitHub.

github.com

[Swift] 연속된 부분 수열의 합 문제 풀이 [Programmers - Level2]

보라봉_ — Tue, 18 Apr 2023 19:32:04 +0900

문제

https://school.programmers.co.kr/learn/courses/30/lessons/178870

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

Idea

투포인터를 이용해서 풀이하자는 아이디어를 떠올려 풀이했다.
연속된 부분 수열의 합을 저장하는 sum 변수를 두고,
- 현재 누적합이 k보다 작거나 같다면 p2(right)를 1씩 증가 (오른쪽 포인터 증가)
  - p2를 증가시키면서 수열을 늘리기 때문에 p2를 증가시키고 누적합에다 p2 원소만큼을 더해줌.
- 현재 누적합이 k보다 크다면 p1(left)를 1씩 증가 (왼쪽 포인터 증가)
  - p1을 증가시키면서 수열을 좁히기 때문에 누적합에서 p1 원소만큼을 빼주고 p1을 증가시킴.
합이 k인 부분 수열이 여러 개인 경우 길이가 짧은 수열을 찾고, 길이가 짧은 수열이 여러 개인 경우 앞쪽(시작 인덱스가 작은)에 나오는 수열을 찾기 위해 정렬한다.
- [시작 인덱스, 끝 인덱스]를 기준으로 끝 인덱스에서 시작인덱스를 뺀 값이 작은 순서대로 정렬한다.
- 이 때 끝 인덱스에서 시작인덱스를 뺀 값이 같다면, 시작 인덱스가 작은 순대로 정렬한다.

풀이

import Foundation

func solution(sequence:[Int], k:Int) -> [Int] {
    var sum = sequence[0]
    var p1 = 0
    var p2 = 0
    var ans: [[Int]] = []
    
    while p1 < sequence.count && p2 < sequence.count {
        if sum == k {
            ans.append([p1, p2])
        }
        
        if sum <= k {
            p2 += 1
            if p2 == sequence.count { break }
            sum += sequence[p2]
        } else {
            sum -= sequence[p1]
            p1 += 1
        }
    }
    
    ans = ans.sorted(by: {
        if $0[1] - $0[0] == $1[1] - $1[0] {
            return $0[0] < $1[0]
        } else {
            return $0[1] - $0[0] < $1[1] - $1[0]
        }
    })
    
    return ans.isEmpty ? [] : ans[0]
}

[Swift] 11726번: 2xn 타일링 문제 풀이 [BOJ - Silver3]

보라봉_ — Thu, 6 Apr 2023 19:49:04 +0900

문제

https://www.acmicpc.net/problem/11726

11726번: 2×n 타일링

2×n 크기의 직사각형을 1×2, 2×1 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오. 아래 그림은 2×5 크기의 직사각형을 채운 한 가지 방법의 예이다.

www.acmicpc.net

Idea

2×n 크기의 직사각형을 1×2, 2×1 타일로 채우는 방법의 수를 구하자.

주어지는 직사각형의 너비 길이가 길어짐에 따라 이를 2x1, 1x2의 작은 단위 조합으로 쪼개어 본다면 규칙을 찾을 수 있었다.

기본적으로

2x1 크기의 직사각형은 2x1 타일 1개로만 채워질 수 있기에 1가지의 방법을 갖고

2x2 크기의 직사각형은 2x1 타일 2개 또는 1x2 타일 2개로 채워질 수 있기에 2가지의 방법을 갖는다.

다음으로 2x3 크기의 직사각형을 채우는 방법의 수를 알아보자.

2x3 크기의 직사각형을 2x1 과 1x2를 기준으로 쪼개어 본다면 아래 두 개의 조합이 나온다.

2x1 타일 1개 + 2x2 타일 1개
- 우리는 이전 단계에서 2x2 타일을 채우는 방법의 수를 구해놓았으므로 2가지임을 알 수 있다.
- 따라서 2x1 타일 1개와 2x2 타일 1개 조합으로 채울 수 있는 방법은 2가지 이다.
1x2 타일 2개 + 2x1 타일 1개
- 2x1 타일을 채우는 방법의 수는 1가지이다.

위 두 개의 조합의 가지수를 더하면 2x3 크기의 직사각형을 채울 수 있는 방법의 수를 도출할 수 있으므로

2x3 크기의 직사각형을 채울 수 있는 방법의 수는 3개이다. (2 + 1 = 3)

다음으로 2x4 크기의 직사각형을 채우는 방법의 수를 알아보자.

2x4 크기의 직사각형을 2x1 과 1x2를 기준으로 쪼개어 본다면 아래 두 개의 조합이 나온다.

2x1 타일 1개 + 2x3 타일 1개
- 2x3 타일을 채우는 방법의 수를 우리는 이전 단계에서 구해놓았으므로 3가지임을 알 수 있다.
- 따라서 2x1 타일 1개 + 2x3 타일 1개 조합으로 채울 수 있는 방법은 3가지 이다.
1x2 타일 2개 + 2x2 타일 1개
- 2x2 타일을 채우는 방법의 수를 우리는 이전 단계에서 구해놓았으므로 2가지임을 알 수 있다.
- 따라서 2x1 타일 1개 + 2x2 타일 1개 조합으로 채울 수 있는 방법은 2가지 이다.

위 두 개의 조합의 가지수를 더하여 2x4 크기의 직사각형을 채울 수 있는 방법의 수를 도출할 수 있으므로

2x4 크기의 직사각형을 채울 수 있는 방법의 수는 5개이다. (3 + 2 = 5)

이렇게 직사각형을 쪼개어 생각해볼 수 있고 단계를 반복할 수록 아래와 같은 규칙을 따른다.

즉 2xn의 직사각형 을 1x2, 2x1의 타일로 채울 수 있는 방법의 수를 알기 위해서는

→ 이전 두개의 항 각각의 방법의 개수를 알고 있다면 해결할 수 있게 된다.

이를 점화식으로 표현해본다면 아래와 같다.

풀이

import Foundation

func solution11726() {
    let N = Int(readLine()!)!
    var rectangleArr = Array(repeating: 0, count: N + 1)
    
    if N == 1 {
        print(1)
    } else if N == 2 {
        print(2)
    } else {
        rectangleArr[1] = 1
        rectangleArr[2] = 2
        
        for i in 3...N {
            rectangleArr[i] = (rectangleArr[i - 1] + rectangleArr[i - 2]) % 10007
        }
        
        print(rectangleArr[N])
    }
}

https://github.com/hwangJi-dev/swiftAlgorithm/blob/main/Programmers/Boj/11726_2%C3%97n%20%ED%83%80%EC%9D%BC%EB%A7%81.swift

GitHub - hwangJi-dev/swiftAlgorithm: Algorithm Practice with Swift

Algorithm Practice with Swift. Contribute to hwangJi-dev/swiftAlgorithm development by creating an account on GitHub.

github.com

[Swift] 9095번: 1, 2, 3 더하기 문제 풀이 [BOJ - Silver3]

보라봉_ — Thu, 6 Apr 2023 02:48:41 +0900

문제

https://www.acmicpc.net/problem/9095

9095번: 1, 2, 3 더하기

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 출력한다.

www.acmicpc.net

이 문제는 DP의 기본문제라고 할 수 있습니다.

그치만 아직 DP가 익숙하지 않아서 점화식이 바로바로 떠오르지가 않았기에 깊게 고민이 필요했어요..

후우 뭔가 알 것 같은데.. 규칙이 보일 것 같은데, 머릿속에서 얽혀버려서 결국 다른 풀이를 참고했습니다!

풀이를 참고하고 보니 접근법까지는 맞았는데, 어느샌가 1, 2, 3의 합으로 나타내는 이라는 중요한 key point를 놓치고 있었어요.

진짜 DP는 풀이를 참고하면 할수록 신세계인 것 같아요 .. 어떤 분이 블로그에 고민하다가 보는 DP 풀이는 정말 신세계고 그런걸 많이많이 경험해보라 하셨는데 너무너무 공감이 가네요! ㅎㅎ

제 블로그를 참고하시는 여러분도 DP의 신세계를 경험하는데 조금이나마 도움이 되길 바라며 풀이를 올려보겠습니다!

Idea

바텀업 방식으로 DP를 구현

[기본 정보]

1	1	1가지
2	1 + 1 2	2가지
3	1 + 1 + 1 1 + 2 2 + 1 3	4가지

기본적으로 1, 2, 3은 각각 1, 2, 3의 합으로 나타내는 방법으로 1, 2, 4가지의 방법을 갖고 있습니다.

[규칙]

그럼 다음으로 4가 어떻게 만들어질 수 있는지 살펴보겠습니다!

4	1 + 3 2 + 2 3 + 1

4를 만들 때 1을 포함하여 4를 만들려면 → 3이라는 숫자가 필요
이 때 3을 1, 2, 3의 합으로 나타내는 방법은 4가지라는 것을 우리는 이미 알고 있음
→ 따라서 숫자 4를 1 + 3의 조합으로 만들 수 있는 방법은 4가지

1 + 3
1 + 1 + 2
1 + 2 + 1
1 + 1 + 1 + 1

4를 만들 때 2를 포함하여 4를 만들려면 → 2라는 숫자가 필요

이 때 2을 1, 2, 3의 합으로 나타내는 방법은 2가지라는 것을 우리는 이미 알고 있음

→ 따라서 숫자 4를 2 + 2의 조합으로 만들 수 있는 방법은 2가지

2 + 1 + 1
2 + 2

4를 만들 때 3을 포함하여 4를 만들려면 → 1이라는 숫자가 필요

이 때 1을 1, 2, 3의 합으로 나타내는 방법은 1가지라는 것을 우리는 이미 알고 있음

→ 따라서 숫자 4를 3 + 1의 조합으로 만들 수 있는 방법은 1가지

3 + 1

따라서 최종적으로 4를 1, 2, 3의 합으로 나타내는 방법은 7가지 입니다.

여기서 볼 수 있는 규칙은 4가 이전 세개의 항인 1, 2, 3이 가지는 방법의 수를 더한 개수만큼 방법을 가진다는 것인데요,

4	1 + 3	1 + 3 1 + 1 + 2 1 + 2 + 1 1 + 1 + 1 + 1
	2 + 2	2 + 1 + 1 2 + 2
	3 + 1	3 + 1
		합: 4 + 2 + 1 = 7

1 - 1개

2 - 2개

3 - 4개

4 - 7개 == 1 + 2 + 4

✅ 규칙을 확실히 알아보기 위해서 정수 5를 1, 2, 3의 합으로 나타내는 방법도 한번 살펴보도록 합시다!!

5	1 + 4 2 + 3 3 + 2

5를 만들 때 1을 포함하여 5를 만들려면 → 4라는 숫자가 필요

이 때 4을 1, 2, 3의 합으로 나타내는 방법은 7가지라는 것을 우리는 이미 알고 있음

→ 따라서 숫자 5를 1 + 4의 조합으로 만들 수 있는 방법은 7가지

1 + 1 + 1 + 1 + 1
1 + 1 + 1+ 2
1 + 1 + 2 + 1
1 + 1 + 3
1 + 2 + 1 + 1
1 + 2+ 2
1 + 3 + 1

5를 만들 때 2를 포함하여 5를 만들려면 → 3이라는 숫자가 필요

이 때 3을 1, 2, 3의 합으로 나타내는 방법은 4가지라는 것을 우리는 이미 알고 있음

→ 따라서 숫자 5를 2 + 3의 조합으로 만들 수 있는 방법은 4가지

2 + 1 + 1 + 1
2 + 1 + 2
2 + 2 + 1
2 + 3

5를 만들 때 3을 포함하여 5를 만들려면 → 2라는 숫자가 필요

이 때 2를 1, 2, 3의 합으로 나타내는 방법은 2가지라는 것을 우리는 이미 알고 있음

→ 따라서 숫자 5를 3 + 2의 조합으로 만들 수 있는 방법은 2가지

3 + 1 + 1
3 + 2

따라서 최종적으로 5를 1, 2, 3의 합으로 나타내는 방법은 13가지 입니다. (7 + 4 + 2)

5	1 + 4	1 + 1 + 1 + 1 + 1 1 + 1 + 1+ 2 1 + 1 + 2 + 1 1 + 1 + 3 1 + 2 + 1 + 1 1 + 2+ 2 1 + 3 + 1
	2 + 3	2 + 1 + 1 + 1 2 + 1 + 2 2 + 2 + 1 2 + 3
	3 + 2	3 + 1 + 1 3 + 2
		합: 7 + 4 + 2 = 13

5를 나타내는 방법까지 알아보고 나니 이제 규칙이 확실해진 것 같지 않나요?

4를 나타내는 방법을 도출하기 위해 알아야 했던 수가 (1 + 3, 2 + 2, 3 + 1) 3, 2, 1 이었고,

5를 나타내는 방법을 도출하기 위해 알아야 했던 수가 (1 + 4, 2 + 3, 3 +2) 4, 3, 2 였습니다.

6을 나타내는 방법을 도출하기 위해 알아야 하는 수는 (1 + 5, 2 + 4, 3 + 3) 5, 4, 3 일테고

7을 나타내는 방법을 도출하기 위해 알아야 하는 수는 (1 + 6, 2 + 5, 3 + 4) 6, 5, 4 이겠죠?

즉 어떤 정수 n을 1, 2, 3의 합으로 나타내는 방법을 알기 위해서는
→ 이전 세개의 항 각각의 방법의 개수를 알고 있다면 해결할 수 있게 된다는 말입니다.

따라서 이 문제의 점화식은 아래와 같이 표현할 수 있습니다.

원리를 이해하고 나니 "한 번 계산한 문제는 다시 계산하지 않도록 하는 알고리즘인 DP"와 참 찰떡콩떡 인 문제죠 ~?

위 아이디어를 코드로 표현하면 아래와 같습니다!

풀이

import Foundation

func solution9095() {
    let TC = Int(readLine()!)!
    var sumCaseArr = Array(repeating: 0, count: 11)
    
    sumCaseArr[1] = 1
    sumCaseArr[2] = 2
    sumCaseArr[3] = 4
    
    for i in 4...10 {
        sumCaseArr[i] = sumCaseArr[i - 1] + sumCaseArr[i - 2] + sumCaseArr[i - 3]
    }
    
    for _ in 0..<TC {
        let n = Int(readLine()!)!
        print(sumCaseArr[n])
    }
}

DP.. 간단한 문제인데도 참 어렵네요!!

그렇지만 중요한건 꺾이지 않는 마음이겠죠!

https://github.com/hwangJi-dev/swiftAlgorithm/blob/main/Programmers/Boj/9095_1%2C%202%2C%203%20%EB%8D%94%ED%95%98%EA%B8%B0.swift

GitHub - hwangJi-dev/swiftAlgorithm: Algorithm Practice with Swift

Algorithm Practice with Swift. Contribute to hwangJi-dev/swiftAlgorithm development by creating an account on GitHub.

github.com

[Swift] 삼각 달팽이 문제 풀이 [Programmers - Level2]

보라봉_ — Wed, 5 Apr 2023 01:53:35 +0900

문제

https://school.programmers.co.kr/learn/courses/30/lessons/68645

프로그래머스

programmers.co.kr

Idea

삼각형을 채울 때 n에서부터 ↙️ ➡️ ↖️ 의 규칙을 따르며 숫자가 채워지고, 채워지는 기준 개수가 -1씩 줄어든다는 것을 발견하여
해당 원리를 이용해 문제를 풀이했다.

반복문을 돌며 trianglePoint 변수를 1씩 증가하면서, 3으로 나눈 나머지로 규칙을 갖게끔 설계하였다.
(삼각형이므로 3씩 기점으로 패턴이 반복됨)

3으로 나눈 나머지가 1일 때 : 하강 (y--)
3으로 나눈 나머지가 2일 때 : 오른쪽으로 이동 (x++)
3으로 나눈 나머지가 0일 때 : 상승 (y++)

<예시 N = 5 일 때 >
[[0], [0,0], [0,0,0], [0,0,0,0], [0,0,0,0,0]] 배열이 [[1], [2,12], [3,13,11], [4,14,15,10], [5,6,7,8,9]] 와 같이 채워진다.

# 1️⃣단계 (↙️ 밑으로 하강하며 채우기)

N = 5
밑으로 하강하면서 [0][0], [1][0], [2][0], [3][0], [4][0]이 채워진다.

# 2️⃣단계 (➡️ 오른쪽으로 이동하며 채우기)

N = 4
오른쪽으로 이동하면서 [4][1], [4][2], [4][3], [4][4]가 채워진다.

N = 3
위로 상승하면서 [3][3], [2][2], [1][1]이 채워진다.

# 3️⃣단계 (↖️ 위로 상승하면서 채우기)

# 4️⃣단계 (↙️ 밑으로 하강하면서 채우기)

N = 2
밑으로 하강하면서 [2][1], [3][1]이 채워진다.

# 5️⃣단계 (➡️ 오른쪽으로 이동하며 채우기)

N = 1
오른쪽으로 이동하면서 [3][2]가 채워진다.

풀이

import Foundation

func solution(_ n:Int) -> [Int] {
    var n = n
    var trianglePoint = 1
    var triangleFilledCnt = 0 // 삼각형에 채워지는 숫자 개수
    var number = 0 // 계속 오르는 숫자
    var y = -1 // y 좌표
    var ansArr: [[Int]] = []
    
    for i in 1...n {
        ansArr.append(Array(repeating: 0, count: i))
    }
    
    while n > 0 {
        number += 1
        triangleFilledCnt += 1
        
        switch trianglePoint % 3 {
        case 0: // 상승하면서 채워짐
            y -= 1
            ansArr[y][ansArr[y].lastIndex(of: 0) ?? 0] = number
        case 1: // 하강하면서 채워짐
            y += 1
            ansArr[y][ansArr[y].firstIndex(of: 0) ?? 0] = number
        default: // 가장 밑단만 채워짐
            ansArr[y][ansArr[y].firstIndex(of: 0) ?? 0] = number
        }
         
        // 기점 예시: 5 / 4 / 3 / 2 / 1
        if triangleFilledCnt == n {
            n -= 1 // 기준 숫자 - 1
            trianglePoint += 1 // 삼각형 point + 1
            triangleFilledCnt = 0
        }
    }
    
    return ansArr.flatMap({ $0 })
}

https://github.com/hwangJi-dev/swiftAlgorithm/blob/main/Programmers/Programmers/level2/%EC%82%BC%EA%B0%81%20%EB%8B%AC%ED%8C%BD%EC%9D%B4.swift

GitHub - hwangJi-dev/swiftAlgorithm: Algorithm Practice with Swift

Algorithm Practice with Swift. Contribute to hwangJi-dev/swiftAlgorithm development by creating an account on GitHub.

github.com

[Swift] 조이스틱 문제 풀이 [Programmers - Level2]

보라봉_ — Tue, 4 Apr 2023 17:53:13 +0900

문제

https://school.programmers.co.kr/learn/courses/30/lessons/42860

프로그래머스

programmers.co.kr

처음엔 그리디 유형의 문제라고 해서 어떻게든 간단한 풀이방법을 찾아내려고 했습니다.
그렇지만 최선의 결과를 도출하려면 이동의 경우의 수를 모두 파악하고 계산할 필요가 있었습니다.
순간 재귀로 풀까 하는 생각이 들어서, 그리디로 풀이하는 힌트를 얻고자 질문하기에 들어갔는데 사람들이 화가 많이 나있었어요 ! ㅋㅋㅋㅋㅋㅠㅠㅠ 넘 공감...
질문하기를 살펴보니 그리디로는 최소 이동 횟수를 파악하기 힘든 문제였습니다. 따라서 dfs(재귀)를 이용해서 풀이해주었습니다.
- 그리디로는 왼쪽, 오른쪽 둘다 이동하는 경우를 도출하기 어렵기 때문인 것 같아요. 그럼에도 그리디로 푸신 분들이 있더라고요 .. 존경스럽습니다,,!!

Idea

조이스틱을 상하로 이동시켜 알파벳을 만들어줄 때 알파벳별 최소 이동횟수를 미리 저장해준다.
- 알파벳 O부터는 Z부터 거슬러올라가는 것이 더 빠르므로 Unicode.Scalar를 응용하여 A~N / O~Z 의 경우를 나누어서 최소 이동횟수를 abcDict에 저장해주었다.
완성해야하는 name의 첫 번째 알파벳이 “A”가 아니라면 조이스틱으로 이동시켜 첫 번째 알파벳을 만들어준다.
이후 첫 번째 커서 위치에서(0) dfs를 수행한다.
- 오른쪽 으로 이동하여 도달할 수 있는 A가 아닌 알파벳을 찾아 dfs를 수행한다. (재귀)
- 왼쪽 으로 이동하여 도달할 수 있는 A가 아닌 알파벳을 찾아 dfs를 수행한다. (재귀)
이렇게 오른쪽, 왼쪽 모두 이동하며 얻게 되는 최소 카운트를 res에 저장하고 함수를 종료한다.
결과를 도출할 때 첫 번째 알파벳을 만들어주기 위해 이동시켰던 횟수만큼을 더해준다.

풀이

import Foundation

func solution(_ name:String) -> Int {
    var abcDict: [String: Int] = [:]
    let name = name.map({ String($0) })
    var initialName = Array(repeating: "A", count: name.count)
    var res = Int.max
    
    for i in 1...26 {
        if let scalar = Unicode.Scalar(64 + i) {
            if i <= 14 {
                abcDict[scalar.description] = i - 1
            } else {
                abcDict[scalar.description] = abs(i - 26) + 1
            }
        }
    }
    //"A": 0, B": 1, "C": 2, "D": 3, "E": 4, "F": 5, "G": 6, "H": 7, "I": 8, "J": 9, "K": 10, "L": 11, "M": 12, "N": 13, "O": 12, "P": 11, "Q": 10, "R": 9, "S": 8, "T": 7, "U": 6, "V": 5, "W": 4, "X": 3, "Y": 2, "Z": 1
    
    if name[0] != "A" {
        initialName[0] = name[0]
    }
    
    /// dfs
    func dfs(_ initialName: [String], _ count: Int, _ cursor: Int) {
        if initialName == name {
            res = min(res, count)
            return
        }
        
        // right
        let right = joystickMovesLeftorRight(true, cursor, name, initialName)
        var rightName = initialName
        var rightCount = count
        rightName[right[0]] = name[right[0]]
        rightCount += abcDict[name[right[0]]]! + right[1]
        dfs(rightName, rightCount, right[0])
        
        // left
        let left = joystickMovesLeftorRight(false, cursor, name, initialName)
        var leftName = initialName
        var leftCount = count
        leftName[left[0]] = name[left[0]]
        leftCount += abcDict[name[left[0]]]! + left[1]
        dfs(leftName, leftCount, left[0])
    }
    
    dfs(initialName, 0, 0)
    return name[0] != "A" ? res + abcDict[name[0]]! : res
}

// MARK: - 조이스틱 좌/우로 이동 후 커서와 이동횟수를 반환하는 메서드
func joystickMovesLeftorRight(_ isRight: Bool, _ cursor: Int, _ name: [String], _ initialName: [String]) -> [Int] {
    var cursor = cursor
    var moves = 0
    
    for _ in name {
        cursor = isRight ? cursor + 1 : cursor - 1 // 오른쪽으로 커서 이동시 + 1 / 왼쪽으로 커서 이동시 - 1
        moves += 1 // 이동횟수는 어떤 경우든 + 1
        
        if cursor > name.count - 1 {
            cursor = 0
        }
        
        if cursor < 0 {
            cursor = name.count - 1
        }
        
				// 찾아야하는 알파벳: A가 아니면서 아직 변환되지 않은 것
        if name[cursor] != "A" && initialName[cursor] == "A" {
            break
        }
    }
    
    return [cursor, moves]
}

근데.. 풀이 후 실행을 시켜봤는데 테스트케이스 7번만 실패가 떴어요... !
40이 최소횟수가 아닌가…? 기댓값이 왜 더 크지 함수 설계 잘못했나 아찔했습니다..

이게 실패해서 공책에다 테스트케이스 직접 계산해봤는데,, 최소가 40이 맞는 것 같아서 제출을 해보았습니다.

이게 웬걸..? ㅋㅋㅋㅋㅋ 정확성이 맞네요,,,,?

혼돈의 조이스틱.. 문제 갖고오면서 설명에서 빠뜨린 조건이 있는걸까요,,?
테스트 7번 정답이 42인 이유가 궁금합니다.....

[테스트 7번 최소 이동로직]

JAANAAAAN (name)

AAAAAAAAA (initial)

1. 첫번째 알파벳 A -> J 로 변경
JAAAAAAAA (+9)

2. 인덱스 0에서 왼쪽으로 커서를 이동시켜 끝 인덱스에 위치한 N으로 이동 (+1)
A -> N 변경 (+13)

3. 마지막 인덱스에서 오른쪽으로 커서를 이동시켜 인덱스 3의 N으로 도달 (+4)
A -> N 변경 (+13)

= 9 + 1 + 13 + 4 + 13 = 40

제가 생각한 로직은 이러해서 40이 도출되었는데, 혹시 이상한 부분이 있다면 댓글로 알려주시면 감사하겠습니다..!!

https://github.com/hwangJi-dev/swiftAlgorithm/blob/main/Programmers/Programmers/level2/%EC%A1%B0%EC%9D%B4%EC%8A%A4%ED%8B%B1.swift

GitHub - hwangJi-dev/swiftAlgorithm: Algorithm Practice with Swift

Algorithm Practice with Swift. Contribute to hwangJi-dev/swiftAlgorithm development by creating an account on GitHub.

github.com

[Swift] 불량 사용자 문제 풀이 [Programmers - Level3 (2019 카카오 개발자 겨울 인턴십)]

보라봉_ — Mon, 3 Apr 2023 20:08:43 +0900

안녕하세요 보라봉입니다 :)

요즘 문제를 풀면서 이전보다 다른 풀이를 참고하는 일이 적어졌다는 걸 느꼈습니다! 아주 조금은 발전한 것 같다는 생각이 들었고, 그러면서 블로그에 저만의 알고리즘 풀이를 올리는 빈도가 늘게 된 것 같아요. 특히 프로그래머스 레벨2를 풀기 시작하면서는 이렇게 푸는게 맞나 고민하는 시간도 많았고, 1시간이 지나도 끙끙대면서 결국 다른 분의 풀이를 참고해서 문제를 해결하는 경우가 많았습니다. 그러면서 자신감도 조금씩 사라졌었는데요.. 알고리즘을 계속 공부하고 또 도전하면서, 점점 높은 레벨의 문제를 도전하고 풀어보면서 제 온전한 힘으로 문제를 풀게 되는 빈도도 늘어나는 것 같슴니다...! ~~(그렇지만 아직도 어려운 알고리즘의 길..)~~

이 재미와 희열감 때문에 개발공부가 즐거웠고 개발을 좋아하게 되었었는데.. 요즘 공부를 하면서 잊었던 열정이 조금씩 살아나는 것 같습니다. 특히 제가 개발 공부를 시작하면서 느꼈던 재미를 다시 느끼고 있어서 너무 좋고 하루하루가 뿌듯한 것 같네요 ㅎㅎ 더 파이팅해야겠습니다! 이 글을 읽는 모든 분들께도 파이팅이 전달되면 좋겠네요 오늘도 같이 힘내봅시다 ~!

문제

https://school.programmers.co.kr/learn/courses/30/lessons/64064

프로그래머스

programmers.co.kr

Idea

불량 사용자 id에 해당하는 사용자 id의 인덱스를 저장할 수 있도록 dictionary를 만들고, 반복문을 돌면서 dictionary에 값을 채운다.
- ["fr*d*": ["frodo", “fradi”], "*rodo": ["frodo", "crodo"], "*****": ["abc123", "frodoc"]] 를 떠올리며 추후에 dfs를 수행할 때 편리하도록 실제 구현시에는 사용자 id의 인덱스값을 저장한다.
- ⇒ ["fr*d*": Set([0, 1]), "*rodo": Set([0, 2]), “*****”: Set([3, 4])]
dfs를 수행하며 불량 제재 아이디와 사용자 아이디를 맵핑한 쌍을 만든다.
- dfs를 활용해야겠다고 떠올리면서, dfs의 깊이(=depth)를 banned_id 배열의 index로 응용하였다.
- 즉, banned_id = ["fr*d*", "abc1**"] 의 경우
  - depth가 0일 때 → fr*d*에 해당하는 user_id가 결정되고
  - depth가 1일 때 → abc1** 에 해당하는 user_id가 결정된다.
  - 이렇게 depth가 깊어지면서 banned_id에 해당하는 유저의 id가 하나씩 결정되므로 depth의 최종 깊이가 되었을 때 하나의 제재 아이디 목록(bannedCase) 쌍이 생긴다.
[ dfs 설계 ]
- visited: user_id의 방문 여부(=현재 쌍에 포함되었는지)를 저장하는 visited 배열이다.
- depth : 불량 아이디 목록의 index로서, dfs의 깊이를 뜻한다.
- userIdx: 유저 아이디의 인덱스이다. visited 여부를 파악하고, 제재 아이디 쌍을 만드는데 사용된다.
- bannedCase: 제재 아이디 쌍이 저장되는 Set<String>형 배열이다.
1. 현재 userIdx가 방문되지 않았다면, 현재 userIdx를 방문처리하고, bannedCase에 현재 user_id를 저장한다.
2. 이후 다음 깊이가 존재한다면 (depth + 1가 banned_id의 개수보다 작다면)
  - 다음 깊이에 해당하는 제재 id 후보들을 차례로 돌며 dfs를 수행한다.
3. 제재 아이디 쌍의 개수가 깊이와 같아졌다면 제재 아이디 쌍을 저장하는 bannedCases에 해당 쌍을 저장하고 함수를 종료한다.
제재 아이디 목록들을 구했을 때 아이디들이 나열된 순서와 관계없이 아이디 목록의 내용이 동일하다면 같은 것으로 처리하여 하나로 세면 됩니다 라는 조건을 해결하기 위해서 Set<Set<String>> 자료구조를 사용해주었다.
- 해당 조건을 처리하기 위해 처음에는 bannedCases를 Set<[String]> 으로 디자인하여 하나의 제재 아이디 목록(bannedCase)이 만들어지면 해당 배열을 정렬하여 bannedCases에 insert해주었다.
하지만 해당 작업이 시간초과를 유발한다는 것을 깨닫고 bannedCases 자체를 Set<Set<String>> 자료구조로 바꿔 구현해주었다.
→ case3번 시간초과가 떴었는데, 해당 방법으로 해결할 수 있었다.

풀이

import Foundation

func solution(_ user_id:[String], _ banned_id:[String]) -> Int {
    var banUserDict: [String: Set<Int>] = [:]
    var bannedCases: Set<Set<String>> = []

    for b in banned_id {
        if banUserDict[b] == nil {
            banUserDict[b] = []
        }

        for (udx, u) in user_id.enumerated() {
            if checkBanId(u, b) {
                banUserDict[b]?.insert(udx)
            }
        }
    }
    
    /// dfs 수행 재귀함수
    func dfs(_ depth: Int, _ userIdx: Int, _ bannedCase: Set<String>, _ visited: [Bool]) {
        var bannedCase = bannedCase
        var visited = visited
        
        // 현재 userIdx가 방문되지 않았다면
        if !visited[userIdx] {
            // 현재 userIdx를 방문처리
            visited[userIdx] = true
            // bannedCase에 현재 user_id를 저장
            bannedCase.insert(user_id[userIdx])
            
            // 다음 깊이가 존재한다면
            if depth + 1 < banned_id.count {
                // 다음 깊이에 해당하는 제재 id 후보들을 차례로 돌며
                for i in banUserDict[banned_id[depth + 1]]! {
                    // dfs를 수행
                    dfs(depth + 1, i, bannedCase, visited)
                }
            }
        }

        // 제재 아이디 쌍의 개수가 깊이와 같아졌다면
        if bannedCase.count == banned_id.count {
            // 제재 아이디 쌍을 저장
            bannedCases.insert(bannedCase)
            // 함수 종료
            return
        }
    }

    let visited = Array(repeating: false, count: user_id.count)
    
    for i in banUserDict[banned_id[0]]! {
        // 깊이 0부터 dfs 수행
        dfs(0, i, [], visited)
    }

    return bannedCases.count
}

// MARK: - 제한당한 id인지 확인하고 제한여부를 리턴하는 메서드
func checkBanId(_ user_id: String, _ banned_id: String) -> Bool {
    if banned_id.count != user_id.count { return false }

    let userID = Array(user_id)
    for (idx, i) in banned_id.enumerated() {
        if i != "*" && i != userID[idx] { return false }
    }

    return true
}

제출 후 해당 문제는 dfs가 중점이라기보단, HashSet을 잘 응용하여 문제를 푸는 능력이 요구되었던 것 같다는 생각이 들어서 순열(permutation)을 이용하여 해당 문제를 한번 더 풀이해보았다 !

Idea

순열은 조합과 달리, index 정보에 따라 다른 조합을 만들어내므로 해당 문제에 순열이 적합하다는 생각이 들었다.

banned_id.count 크기의 순열을 생성하여 perm에 저장한다.
이후 perm을 돌면서 perm의 원소의 index와 banned_id의 index를 맵핑하여 checkBanId를 수행한다.
- perm = [["frodo", "fradi"], ["frodo", "crodo"], ["frodo", "abc123"], ["frodo", "frodoc"], ["fradi", "frodo"], ["fradi", "crodo"], ["fradi", "abc123"], ["fradi", "frodoc"], ["crodo", "frodo"], ["crodo", "fradi"], ["crodo", "abc123"], ["crodo", "frodoc"], ["abc123", "frodo"], ["abc123", "fradi"], ["abc123", "crodo"], ["abc123", "frodoc"], ["frodoc", "frodo"], ["frodoc", "fradi"], ["frodoc", "crodo"], ["frodoc", "abc123"]]
- banned_id = ["fr*d*", "abc1**"]
perm[0]인 ["frodo", "fradi"] 를 예로 들어보자. (perm[0]을 p로 지칭하겠다.)
p[0] = "frodo" 와 banned_id[0] = "fr*d*" 를 맵핑하여 checkBanId를 수행한다.
p의 모든 원소가 banned_id와 맵핑된다면 해당 조합은 제재 아이디 목록에 해당됨을 뜻하므로 bannedCases에 넣어준다.
bannedCases의 개수를 리턴한다.

풀이

import Foundation

func solution(_ user_id:[String], _ banned_id:[String]) -> Int {
    var bannedCases: Set<Set<String>> = []
    let perm = permutation(user_id, banned_id.count)

    for p in perm {
        var isValid = true
        for (idx, i) in p.enumerated() {
            if !checkBanId(i, banned_id[idx]) {
                isValid = false
            }
        }

        if isValid {
            bannedCases.insert(Set(p))
        }
    }

    return bannedCases.count
}

// MARK: - 순열 메서드
func permutation(_ array: [String], _ n: Int) -> [[String]] {
    var result = [[String]]()
    if array.count < n { return result }

    var visited = Array(repeating: false, count: array.count)

    func cycle(_ now: [String]) {
        if now.count == n {
            result.append(now)
            return
        }

        for i in 0..<array.count {
            if visited[i] {
                continue
            } else {
                visited[i] = true
                cycle(now + [array[i]])
                visited[i] = false
            }
        }
    }

    cycle([])

    return result
}

// MARK: - 제한당한 id인지 확인하고 제한여부를 리턴하는 메서드
func checkBanId(_ user_id: String, _ banned_id: String) -> Bool {
    if banned_id.count != user_id.count { return false }

    let userID = Array(user_id)
    for (idx, i) in banned_id.enumerated() {
        if i != "*" && i != userID[idx] { return false }
    }

    return true
}

이렇게 불량 사용자 문제를 dfs로 풀어보고, 순열을 이용해서도 풀어보았다.

풀고 나서 살펴보니 두 가지 방법 중 어느 것을 사용하여 푸는지는 중요하지 않았던 것 같다. HashSet 자료구조를 알고, 활용할 줄 안다면 해당 문제를 어떤 방법으로든 풀 수 있기 때문이다!

그렇지만 시간 복잡도 측면에서 불필요한 비교를 줄이는 dfs 방법이 훨씬 더 좋은 효율을 가지기 때문에 dfs가 더 좋은 풀이가 아닐까 생각이 들었다.

https://github.com/hwangJi-dev/swiftAlgorithm/blob/main/Programmers/Programmers/level3/%EB%B6%88%EB%9F%89%20%EC%82%AC%EC%9A%A9%EC%9E%90.swift

GitHub - hwangJi-dev/swiftAlgorithm: Algorithm Practice with Swift

Algorithm Practice with Swift. Contribute to hwangJi-dev/swiftAlgorithm development by creating an account on GitHub.

github.com

[Swift] 7576번: 토마토 문제 풀이 [BOJ - Gold5]

보라봉_ — Sun, 2 Apr 2023 22:30:03 +0900

문제

https://www.acmicpc.net/problem/7576

7576번: 토마토

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N이 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M,N ≤ 1,000 이다. 둘째 줄부터는 하나의 상자에 저장된 토마토

www.acmicpc.net

Idea

토마토가 모두 익을 때까지의 최소 날짜를 구하기 위해서 BFS를 수행하자.

N X M 크기의 tomatos 2차원 배열을 만든다.
저장될 때부터 익혀진 토마토 (=1)의 좌표를 찾아 ripeTomatos 배열에 저장해준다.
만약 저장될 때부터 모든 토마토가 익어있는 상태라면 0을 출력하고, 그렇지 않으면 bfs를 수행한다.
bfs를 수행하기에 앞서 queue에 시작 좌표인 ripeTomatos들을 저장해준다.
- ✅ 1이 여러 개인 경우 여러 지점에서 출발해 토마토를 익혀야함.
이후 queue의 원소를 꺼내면서 상 하 좌 우 좌표에 위치한 토마토들을 익힌다.
bfs가 수행된 이후 모든 토마토가 익었다면 토마토가 모두 익기까지의 최소 날짜를 출력하고, 그렇지 않다면 -1을 출력한다.

풀이

import Foundation

func solution7576() {
    let box = readLine()!.split(separator: " ").map({ Int(String($0))! })
    var tomatos: [[Int]] = []
    var ripeTomatos: [[Int]] = []
    var lastDay = 0
    var isFirstAllRipe = true
    
    for n in 0..<box[1] {
        let tomato = readLine()!.split(separator: " ").map({ Int(String($0))! })
        tomatos.append(tomato)
        
        // 좌표 1 찾기
        for (mdx, m) in tomato.enumerated() {
            if m == 1 {
                ripeTomatos.append([n, mdx])
            } else if m == 0 {
                isFirstAllRipe = false
            }
        }
    }
    
    func bfs() {
        var queue: [[Int]?] = ripeTomatos 
        // queue는 FIFO이므로 이미 익은 좌표들부터 차례로 방문하여 토마토를 익힐 수 있다.
        var pointer = 0
        
        let dx = [-1, 1, 0, 0]
        let dy = [0, 0, -1, 1]
        
        while pointer < queue.count {
            let cx = queue[pointer]![0]
            let cy = queue[pointer]![1]
            queue[pointer] = nil
            pointer += 1
            
            for i in 0...3 {
                let nx = cx + dx[i]
                let ny = cy + dy[i]
                
                if nx < 0 || ny < 0 || nx > tomatos.count - 1 || ny > tomatos[0].count - 1 {
                    continue
                }
                
                if tomatos[nx][ny] == -1 {
                    continue
                }
                
                if tomatos[nx][ny] == 0 {
                    tomatos[nx][ny] = tomatos[cx][cy] + 1
                    queue.append([nx, ny])
                    lastDay = tomatos[nx][ny] - 1
                }
            }
        }
    }
    
    var isAllRipe = true
    
    // 만약, 저장될 때부터 모든 토마토가 익어있는 상태이면 0 출력
    if isFirstAllRipe {
        print(0)
    } else {
        bfs()
        
        for i in tomatos {
            if i.contains(0) {
                isAllRipe = false
            }
        }
        
        if isAllRipe {
            print(lastDay)
        } else {
            // 토마토가 모두 익지는 못하는 상황이면 -1을 출력
            print(-1)
        }
    }
}

bfs를 수행할 때 queue의 첫번째 원소를 꺼내기 위해 removeFirst()를 사용한다면 시간초과가 발생할 수 있기 때문에
본 풀이에서는 포인터의 원리를 이용하여 풀이해보았다

https://github.com/hwangJi-dev/swiftAlgorithm/blob/main/Programmers/Boj/7576_%ED%86%A0%EB%A7%88%ED%86%A0.swift

GitHub - hwangJi-dev/swiftAlgorithm: Algorithm Practice with Swift

Algorithm Practice with Swift. Contribute to hwangJi-dev/swiftAlgorithm development by creating an account on GitHub.

github.com

[Swift] 2178번: 미로 탐색 문제 풀이 [BOJ - Silver1]

보라봉_ — Sat, 1 Apr 2023 20:41:45 +0900

문제

https://www.acmicpc.net/problem/2178

2178번: 미로 탐색

첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 M개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.

www.acmicpc.net

첫 Idea

입력값을 MxN의 2차원 배열로 만들기
방문 여부를 저장하는 visited 배열 만들기
dfs 재귀함수 만들기
1. 이동할 수 있는 좌표계가 아니라면 함수 return하여 탈출
2. 방문되지 않았고, 1로 지나갈 수 있는 미로라면 → 상 하 좌 우 좌표로 이동시키기 (재귀)

⇒ 그러나 dfs 재귀함수로는 시간초과가 발생했다.

그 이유인즉슨!!
dfs는 하나의 노드를 깊게 탐색하기 때문에 해당 노드가 최선의 값을 도출하는 노드가 아닐 경우 기회비용이 더 들게 되기 때문이었다.

풀이

시간초과 발생 DFS 재귀 풀이

import Foundation

func solution2178() {
    let NM = readLine()!.split(separator: " ").map({ Int($0)! })
    var miros: [[Int]] = []
    
    for _ in 0..<NM[0] {
        let miro = readLine()!
        miros.append(Array(miro).map({ Int(String($0))! }))
    }
    
    var visited = Array(repeating: Array(repeating: false, count: miros[0].count), count: miros.count)
    var minDistance = Int.max
    
    func dfs(start: [Int], count: Int) {
        // 이동할 수 있는 좌표계가 아니라면 함수 return
        if start[0] < 0 || start[0] > miros.count - 1 || start[1] < 0 || start[1] > miros[0].count - 1 { return }
        
        // N, M에 도달했다면
        if start == [NM[0] - 1, NM[1] - 1] {
            if minDistance > count {
                minDistance = count
            }
            return
        }
        
        // 방문되지 않았고, 1로 지나갈 수 있는 미로라면
        if !visited[start[0]][start[1]] && miros[start[0]][start[1]] == 1 {
            // 방문 처리
            visited[start[0]][start[1]] = true
            
            // 상 하 좌 우 좌표로 이동
            dfs(start: [start[0] + 1, start[1]], count: count + 1)
            dfs(start: [start[0] - 1, start[1]], count: count + 1)
            dfs(start: [start[0], start[1] + 1], count: count + 1)
            dfs(start: [start[0], start[1] - 1], count: count + 1)
            visited[start[0]][start[1]] = false
        }
    }
    
    dfs(start: [0,0], count: 1)
    print(minDistance)
}

정답 Idea

입력값을 MxN의 2차원 배열로 만들기
BFS함수 만들기
(BFS는 시작 지점에서 가까운 노드부터 차례대로 그래프의 모든 노드를 탐색하기 때문에 BFS를 이용하면 효율적으로 풀이할 수 있다.)
1. 출발지점에서부터 상 하 좌 우 좌표를 구한다.
2. 상 하 좌 우 4가지 경우를 반복문으로 돌면서 처음 지나가는 미로인 경우 (미로 노드 정보가 1인 경우)
  -> 현재 지점의 거리 정보에 1을 더한 값을 저장한다.

정답 풀이

func solution2178() {
    let NM = readLine()!.split(separator: " ").map({ Int($0)! })
    var miros: [[Int]] = []
    
    for _ in 0..<NM[0] {
        let miro = readLine()!
        let miroArr = Array(miro).map({ Int(String($0))! })
        miros.append(miroArr)
    }
    
    // 이동할 네 방향 정의 (좌, 우, 상, 하)
    let dx = [-1, 1, 0, 0]
    let dy = [0, 0, -1, 1]
    
    func bfs(x: Int, y: Int) -> Int {
        var queue: [[Int]] = []
        queue.append([x, y])
        
        while !queue.isEmpty {
            let c = queue.removeFirst()
            // 현위치 cx, cy
            let cx = c[0]
            let cy = c[1]
            
            // 현위치에서 네 방향으로 위치 확인
            for i in 0..<4 {
                let nx = cx + dx[i]
                let ny = cy + dy[i]
                
                // 미로찾기 공간을 벗어난 경우 무시
                if nx < 0 || ny < 0 || nx > miros.count - 1 || ny > miros[0].count - 1 {
                    continue
                }
                
                // 벽인 경우 무시
                if miros[nx][ny] == 0 { continue }
                
                // 해당 노드를 처음 방문하는 경우라면 1이 저장되어 있을 것이므로
                // 해당 경우에만 최단 거리를 기록한다
                if miros[nx][ny] == 1 {
                    // 현재 위치의 거리 정보 + 1
                    miros[nx][ny] = miros[cx][cy] + 1
                    queue.append([nx, ny])
                }
            }
        }
        
        return miros[NM[0] - 1][NM[1] - 1]
    }
    
    print(bfs(x: 0, y: 0))
}

미로 탐색 문제를 풀어보면서 해당 문제처럼 경로의 최단 거리를 구하는 문제는 BFS로 풀이해야 효율적이라는걸 몸소 체감할 수 있었습니다 !!

https://github.com/hwangJi-dev/swiftAlgorithm/blob/main/Programmers/Boj/2178_%EB%AF%B8%EB%A1%9C%ED%83%90%EC%83%89.swift

GitHub - hwangJi-dev/swiftAlgorithm: Algorithm Practice with Swift

Algorithm Practice with Swift. Contribute to hwangJi-dev/swiftAlgorithm development by creating an account on GitHub.

github.com

[Swift] [3차] 압축 문제 풀이 [Programmers - Level2 (2018 KAKAO BLIND RECRUITMENT)]

보라봉_ — Thu, 30 Mar 2023 20:40:45 +0900

문제

https://school.programmers.co.kr/learn/courses/30/lessons/17684

프로그래머스

programmers.co.kr

Idea

먼저 msg 문자열을 Array형태로 변환한 뒤 배열을 뒤집는다.
- 가장 첫번째 문자를 popLast()하기 위해 (배열을 뒤집지 않고 removeFirst()를 수행하게 되면 효율성이 아주 떨어지기 때문이다)

1. 현재 입력과 일치하는 가장 긴 문자열을 찾기 위해 msg의 마지막 원소가 있을 때까지 popLast()를 수행한다.
   -> popLast()한 값을 word 변수에 더해준다.
	✅ 이 때 word + c(msg의 last값)가 사전에 있다면 또 다음 긴 문자를 찾기 위해 반복한다.
	✅ 이 때 word + c(msg의 last값)가 사전에 없다면 해당 값을 사전에 등록하고 반복문을 멈춘다.
	   -> 사전에 등록할 때 사전의 마지막 값을 + 1 하여 업데이트 해준다.

2. 현재 입력과 일치하는 가장 긴 문자열은 word 변수와 일치하므로 ans 배열에 사전의 word 값을 append해준다.
3. msg 배열이 빌 때까지 1,2 과정을 반복한다.

풀이

func solution(msg: String) -> [Int] {
    var msg = Array(msg).reversed().map({ String($0) })
    var dict: [String: Int] = ["A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6, "G": 7, "H": 8, "I": 9, "J": 10, "K": 11, "L": 12, "M": 13, "N": 14, "O": 15, "P": 16, "Q": 17, "R": 18, "S": 19, "T": 20, "U": 21, "V": 22, "W": 23, "X": 24, "Y": 25, "Z": 26]
    var dictLastVal = 26
    var ans: [Int] = []
    
    while !msg.isEmpty {
        var word = ""
        while let w = msg.popLast() {
            word += w
            if let c = msg.last {
                if dict[word + c] == nil {
                    dictLastVal += 1
                    dict[word + c] = dictLastVal
                    break
                }
            }
        }
        ans.append(dict[word]!)
    }
    
    return ans
}

https://github.com/hwangJi-dev/swiftAlgorithm/blob/main/Programmers/Programmers/level2/%5B3%EC%B0%A8%5D%20%EC%95%95%EC%B6%95.swift

GitHub - hwangJi-dev/swiftAlgorithm: Algorithm Practice with Swift

Algorithm Practice with Swift. Contribute to hwangJi-dev/swiftAlgorithm development by creating an account on GitHub.

github.com

더 나은 방법?

문제를 풀면서 사전에 이미 정의되어있는 1개의 단어들을 일일이 초기화해줬는데,
Unicode.Scalar를 통해 숫자를 이용해서 알파벳을 차례대로 표현할 수 있다는 걸 알게되었다.
- 대문자 알파벳 A를 Unicode.Scalar(65)로 표현할 수 있다.
- 이후 차례대로 26개의 알파벳을 표현한다.

var dict: [String: Int] = [:]

for i in 1...26 {
    if let scalar = Unicode.Scalar(64 + i) {
        dict[scalar.description] = i
    }
}

// dict
// ["A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6, "G": 7, "H": 8, "I": 9, "J": 10, "K": 11, "L": 12, "M": 13, "N": 14, "O": 15, "P": 16, "Q": 17, "R": 18, "S": 19, "T": 20, "U": 21, "V": 22, "W": 23, "X": 24, "Y": 25, "Z": 26]

알게된 것

✅ Unicode.Scalar

크기가 가변적인 String 문자열을 하나하나 개별적으로 접근하기 위한 방법.
Unicode기반 21-bit 코드
UTF-32랑 거의 동일하다.
하나 이상의 Unicode Scalar가 모여 Character를 이룬다.
숫자 표현에서 직접 유니코드 스칼라 값을 생성할 수 있다.
- Unicode.Scalar(65) // “A”

<참고>

https://velog.io/@haze5959/Swift-Unicode-Scalar-그리고-문자열-count-시간-복잡도-관계