프로그래머스 - 프렌즈4블록(Swift)

프로그래머스 - 프렌즈4블록(Swift)

 

 

 문제 설명

 

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

프로그래머스

 

 

 나의 풀이

 

지금까지 프로그래머스 문제를 풀면서 가장 긴 코드를 작성한 것 같다. 

매번 생각하지만 코드가 길 수록 코드를 잘 짜지 못한다고 느끼고 이번에 작성한 코드도 문제 발생 -> 문제 해결 -> 문제 발생 -> 문제해결 의 순서를 반복함으로써 풀었기 때문에 좋지 않은 코드가 나왔다고 생각한다.

 

그래도 다른사람의 풀이를 보기 전에 내가 쓴 코드를 복기해본다.

 

check함수는 2가지 역할을 한다.

1. Bool타입의 Flag를 전달함으로써 멈출지 계속할지를 결정한다.

2. Flag가 true가 되어 계속 진행한다면(4칸이 동일한 게 존재한다면) 외부의 배열 arr에 check를 통해 지운배열 bor를 전달해준다.

 

핵심은 i와 j를 돌 때 m-1, n-1까지만 도는 것인데 이는 인덱스가 초과된 부분에 대해서는 검사하지 않도록 하며 answer에 등록된 인덱스들은 시작값만 저장이 되는 것이기 때문에 이들을 for문 돌리면서 주변의 4칸을 공백으로 두면 중복되는 부분들을 고려해서 전부 지울 수 있다.

 

move함수를 작성하는데에는 다른 사람의 접근을 참고했다.

열을 탐색할 때 위에서부터 탐색하면 공백을 발견할 때 값을 땡겨주고 또 위에 것들도 다 땡겨줘야하기 때문에 이는 아래서부터 탐색하는 것이 훨씬 수월하다.

 

아래서부터 탐색하면서 공백일 때는 emptyCount를 1증가시키고 공백이 아닐면서 emptyCount가 0이 아닐때는 인덱스에 emptyCount를 더해서 대체해주면 된다.  

 

이것저것 true, false를 남발하면서 문제는 풀었다는 점에서 스스로에게 칭찬을 하지만, 코드가 너무 길다는 점에서 다른 사람의 코드를 보면서 개선할 점을 찾는다.

 

func solution(_ m:Int, _ n:Int, _ board:[String]) -> Int {
    var arr = board.map{ $0.map{String($0) }}
    var cnt = 0
    func check(_ array: [[String]]) -> Bool {
        var Flag = false
        var bor = array
        var answer: [(Int, Int)] = []
        func isRemove(_ i: Int, _ j: Int) -> Bool {
            if bor[i][j] != "" && bor[i][j] == bor[i][j+1] && bor[i][j] == bor[i+1][j] && bor[i][j] == bor[i+1][j+1]{
                return true
            }
            return false
        }
        
        for i in 0..<m-1 {
            for j in 0..<n-1 {
                if isRemove(i, j) {
                    answer.append((i, j))
                }
            }
        }
        
        for (i, j) in answer {
            Flag = true
            bor[i][j] = ""
            bor[i][j+1] = ""
            bor[i+1][j] = ""
            bor[i+1][j+1] = ""
        }
        if Flag {
            arr = bor
            return true
        } else {
            return false
        }
    }
    
    func move(_ arr: [[String]]) -> [[String]] {
        var moveArr = arr
        for i in 0..<n {
            var emptyCount = 0
            for j in stride(from: m-1, to: -1, by: -1) {
                if moveArr[j][i] != "" {
                    if emptyCount != 0 {
                        moveArr[j+emptyCount][i] = moveArr[j][i]
                        moveArr[j][i] = ""
                    }
                } else {
                    emptyCount += 1
                }
            }
        }
        return moveArr
    }
    
    while true {
        if check(arr) {
            arr = move(arr)
        } else {
            break
        }
    }
    
    for i in 0..<m {
        for j in 0..<n {
            if arr[i][j] == "" {
                cnt += 1
            }
        }
    }
    
    return cnt
}

 

 다른 사람의 풀이

 

board와, temp 배열을 분리시켜서 중복에 대해서 처리한 점과 isChanged를 통해서 배열에 4칸의 값이 있을때 한번 더 while문을 돌 수 있게 한 점이 인상깊었다.

 

그리고 패턴매칭 연산자를 사용해서 인덱스 범위에 대해 쉽게 다룰 수 있었고, guard문으로 열거함으로써 로직을 훨씬 단순화 시켰다.

 

import Foundation

// 사각형 영역이 모두 같은지 확인
func square(_ i: Int, _ j: Int, _ ch: String, _ m: Int, _ n: Int, _ board: [[String]]) -> Bool {
    let squareIndex = [(i, j), (i, j+1), (i+1, j), (i+1, j+1)]
    for (r, c) in squareIndex {
        guard (0..<m) ~= r, (0..<n) ~= c, ch == board[r][c] else { return false }
    }
    
    return true
}

// 빈 블럭을 제거
func removeBlank(_ arr: [[String]], _ m: Int, _ n: Int) -> [[String]] {
    var temp = arr
    for i in 0..<n {
        var emptyCount = 0
        for j in stride(from: m-1, to: -1, by: -1) {
            if temp[j][i] != "-" {
                if emptyCount != 0 {
                    temp[j+emptyCount][i] = temp[j][i]
                    temp[j][i] = "-"
                }
            } else {
                emptyCount += 1
            }
        }
    }
    return temp
}

func solution(_ m:Int, _ n:Int, _ board:[String]) -> Int {
    var board = board.map{ $0.map{ String($0)} }
    var cnt = 0
    var isChanged = true
    
    while isChanged {
        var temp = board
        isChanged = false
        
        for i in 0..<m {
            for j in 0..<n where board[i][j] != "-" {
                if square(i, j, board[i][j], m, n, board) {
                    for (i, j) in [(i, j), (i, j+1), (i+1, j), (i+1, j+1)] {
                        if temp[i][j] != "-" {
                            cnt += 1
                            temp[i][j] = "-"
                        }
                    }
                    isChanged = true
                }
            }
        }
        
        board = removeBlank(temp, m, n)
    }
    
    return cnt
}