18th December solution - Advent of Code 2020 - swift

december18_1.swift

func calcNoBrackets(expression: String) -> Int {
    let parts = expression.components(separatedBy: " ")
    let numbers = parts.enumerated().filter {$0.0 % 2 == 0 && !$0.1.isEmpty }.map { $0.1.toInt() }
    let operators: [((Int,Int) -> Int)] = parts.enumerated().filter {$0.0 % 2 == 1 && !$0.1.isEmpty }.map { $0.1.trimmingCharacters(in: .whitespacesAndNewlines) }.map {
        switch $0 {
        case "*": return (*)
        case "+": return (+)
        default:
            return (+)
        }
    }
    var result = numbers.first!
    for (i, op) in operators.enumerated() {
        result = op(result, numbers[i+1])
    }
    return result
}

december18_2.swift

func calcNoBrackets(expression: String) -> Int {
    let parts = expression.components(separatedBy: " ")
    var numbers = parts.enumerated().filter {$0.0 % 2 == 0 && !$0.1.isEmpty }.map { $0.1.toInt() }
    var operators: [(String, ((Int,Int) -> Int))] = parts.enumerated().filter {$0.0 % 2 == 1 && !$0.1.isEmpty }.map { $0.1.trimmingCharacters(in: .whitespacesAndNewlines) }.map {
        switch $0 {
        case "*": return ($0,*)
        case "+": return ($0,+)
        default:
            return ($0,+)
        }
    }
    var factors = [Int]()
    var i = 0
    while i < operators.count {
        if operators[i].0 == "*" {
            factors.append(numbers[i])
            i += 1
        } else {
            numbers[i] = operators[i].1(numbers[i], numbers[i+1])
            numbers.remove(at: i+1)
            operators.remove(at: i)
        }
    }
    return numbers.reduce(1, *)
}

december18_shared.swift

import Foundation

let filename = "/Users/felix/xCodeProjects/AdventOfCode2020.playground/Resources/december18.txt"
let contents = try! String(contentsOfFile: filename)
let lines = contents.components(separatedBy: CharacterSet.newlines).filter { !$0.isEmpty}

let result = lines.map { line in
    calc(expression: line)
}.reduce(0,+)
print(result)

func calc(expression: String) -> Int {
    if expression.contains("(") {
        var levelCount = 0
        var startIndex: String.Index = expression.startIndex
        var endIndex: String.Index = expression.startIndex
        for i in expression.indices {
            let char = expression[i]
            if char == "(" {
                levelCount += 1
                if levelCount == 1 {
                    startIndex = expression.index(after: i)
                }
            }
            
            if char == ")" {
                levelCount -= 1
                if levelCount == 0 {
                    endIndex = i
                }
            }
        }
        let newExpression = expression.replacingCharacters(in: expression.index(before: startIndex)...endIndex, with: String(calc(expression: String(expression[startIndex..<endIndex]))))
        return calc(expression: newExpression)
    } else {
        return calcNoBrackets(expression: expression)
    }
}

extension String {
    func toInt() -> Int {
        return Int(self.trimmingCharacters(in: .whitespacesAndNewlines))!
    }
}