[프로그래머스] 2020 카카오 인턴십 수식 최대화 with Swift

안녕하세요. 프로그래머스 2레벨 문제 수식 최대화 문제를 풀어보았습니다.

지난번에는 조합문제를 풀어보았던 기억이 있는데 이번엔 순열문제입니다!

 

조합과 순열은 순서가 상관있냐 없냐 차이이기 때문데 재귀에서 0부터 시작하냐 index부터 시작하냐만 다를 뿐 똑같습니다.

 

차후에 알고리즘으로 다루도록하겠습니다!(sort, dfs/bfs, 순열과 조합이 밀려있네요 허헣...)

 

1. 숫자와 연산자를 나눈다! 각각 배열에 담습니다!

    for character in expression {
        
        if let integer = Int(String(character)) {
            number = number * 10 + Int64(integer)
        }
        else {
            numbers.append(number)
            number = 0
            operators.append(String(character))
        }
        
    }
    numbers.append(number)

 

2. 순열을 이용해서 총 6가지 순열을 만듭니다! 재귀를 이용해 만들 수 있습니다! 

func permutation(_ depth:Int) {
    if depth == 3 {
        calculate()
    }
    
    for i in 0..<3 {
        if isUsing[i] != -1 {
                continue
        }
        isUsing[i] = depth
        permutation(depth+1)
        isUsing[i] = -1
        
    }
}

3. 순열별로 우선순위가 정해지므로 그 우선순위에 따라 계산한 결과를 answer과 비교하여 최대값을 담아내면 문제가 해결됩니다!

 

이 부분이 디버깅하기 까다롭지만 논리에 맞게 잘 구현한다면 한번에 넘기실 수 있습니다!

func calculate() {
    var calculateNumbers = numbers
    var calculateOperators = operators
    for priority in isUsing {
        if operatorDictionary[priority] == "+" {
            while true {
                var breakable = true
                for i in 0..<calculateOperators.count {
                    if calculateOperators[i] == operatorDictionary[priority] {
                        breakable = false
                        let integer1 = calculateNumbers.remove(at: i)
                        let integer2 = calculateNumbers.remove(at: i)
                        calculateOperators.remove(at: i)
                        calculateNumbers.insert(integer1 + integer2, at: i)
                        print(calculateNumbers)
                        break
                    }
                }
                if breakable == true {
                    break
                }
            }
        }
        else if operatorDictionary[priority] == "-" {
            while true {
                var breakable = true
                for i in 0..<calculateOperators.count {
                    if calculateOperators[i] == operatorDictionary[priority] {
                        breakable = false
                        let integer1 = calculateNumbers.remove(at: i)
                        let integer2 = calculateNumbers.remove(at: i)
                        calculateOperators.remove(at: i)
                        calculateNumbers.insert(integer1 - integer2, at: i)
                        print(calculateNumbers)
                        break
                    }
                }
                if breakable == true {
                    break
                }
            }
        }
        else if operatorDictionary[priority] == "*" {
            while true {
                var breakable = true
                for i in 0..<calculateOperators.count {
                    if calculateOperators[i] == operatorDictionary[priority] {
                        breakable = false
                        let integer1 = calculateNumbers.remove(at: i)
                        let integer2 = calculateNumbers.remove(at: i)
                        calculateOperators.remove(at: i)
                        calculateNumbers.insert(integer1 * integer2, at: i)
                        print(calculateNumbers)
                        break
                    }
                }
                if breakable == true {
                    break
                }
            }
        }
    }
    if answer < abs(calculateNumbers[0]) {
        answer = abs(calculateNumbers[0])
    }
}

코드가 길어보이지만 중복되는 부분이 많아 뻥튀기입니다! 천천히 본다면 매우 쉽습니다!

 

 

import Foundation

var numbers:[Int64] = []
var operators:[String] = []
var answer:Int64 = 0
let operatorDictionary = [0:"+", 1:"-", 2:"*"]
var isUsing = [Int](repeating: -1, count: 3)

func calculate() {
    var calculateNumbers = numbers
    var calculateOperators = operators
    for priority in isUsing {
        if operatorDictionary[priority] == "+" {
            while true {
                var breakable = true
                for i in 0..<calculateOperators.count {
                    if calculateOperators[i] == operatorDictionary[priority] {
                        breakable = false
                        let integer1 = calculateNumbers.remove(at: i)
                        let integer2 = calculateNumbers.remove(at: i)
                        calculateOperators.remove(at: i)
                        calculateNumbers.insert(integer1 + integer2, at: i)
                        print(calculateNumbers)
                        break
                    }
                }
                if breakable == true {
                    break
                }
            }
        }
        else if operatorDictionary[priority] == "-" {
            while true {
                var breakable = true
                for i in 0..<calculateOperators.count {
                    if calculateOperators[i] == operatorDictionary[priority] {
                        breakable = false
                        let integer1 = calculateNumbers.remove(at: i)
                        let integer2 = calculateNumbers.remove(at: i)
                        calculateOperators.remove(at: i)
                        calculateNumbers.insert(integer1 - integer2, at: i)
                        print(calculateNumbers)
                        break
                    }
                }
                if breakable == true {
                    break
                }
            }
        }
        else if operatorDictionary[priority] == "*" {
            while true {
                var breakable = true
                for i in 0..<calculateOperators.count {
                    if calculateOperators[i] == operatorDictionary[priority] {
                        breakable = false
                        let integer1 = calculateNumbers.remove(at: i)
                        let integer2 = calculateNumbers.remove(at: i)
                        calculateOperators.remove(at: i)
                        calculateNumbers.insert(integer1 * integer2, at: i)
                        print(calculateNumbers)
                        break
                    }
                }
                if breakable == true {
                    break
                }
            }
        }
    }
    if answer < abs(calculateNumbers[0]) {
        answer = abs(calculateNumbers[0])
    }
}

func permutation(_ depth:Int) {
    if depth == 3 {
        calculate()
    }
    
    for i in 0..<3 {
        if isUsing[i] != -1 {
                continue
        }
        isUsing[i] = depth
        permutation(depth+1)
        isUsing[i] = -1
        
    }
}

func solution(_ expression:String) -> Int64 {
    var number:Int64 = 0
    for character in expression {
        
        if let integer = Int(String(character)) {
            number = number * 10 + Int64(integer)
        }
        else {
            numbers.append(number)
            number = 0
            operators.append(String(character))
        }
        
    }
    numbers.append(number)
    
    permutation(0)
    
    return answer
}

오늘은 여기까지이며 질문이 있으시면 언제든지 댓글로 질문 주세요!

 

감사합니다~