백준 Swift 4673번, 1065번, 2941번, 4796번, 9012번, 2164번

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

 

22.02.11 업데이트

22.02.21 업데이트

22.03.07 업데이트

22.03.09 업데이트

22.03.10 업데이트

 

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

 

---

백준 Swift 4673번

// MARK: - 4673번
func d(_ N: Int) -> Int {
    var sum: Int = 0
    let temp: String = String(N)
    var numArray: [Int] = []
    
    for num in temp {
        numArray.append(Int(String(num))!)
    }
    
    sum = N + numArray.reduce(0, +)
    
    return sum
}

var dNum: Set<Int> = []

for n in 1...10000 {
    dNum.insert(d(n))
}

for i in 1...10000 {
    if !dNum.contains(i) {
        print(i)
    }
}

 

---

백준 Swift 1065번

// MARK: - 1065번
let N = Int(readLine()!)!
var count: Int = 0

for i in 1...N {
    var numArray: [Int] = []
    let num = String(i)
    
    for text in num {
        numArray.append(Int(String(text))!)
    }
    
    if numArray.count == 1 { // 1자리 수라면, (0~9)
        count += 1
    }
    else {
        let d: Int = numArray[1] - numArray[0] // 공차
        var flag: Bool = true // 등차수열인가?
        
        for j in 0..<numArray.count-1 {
            if numArray[j] + d != numArray[j+1] { // 등차수열 아니면,
                flag = false
                break
            }
        }
        
        if flag == true { // 등차수열이라면,
            count += 1
        }
    }
}

print(count)

 

---

백준 Swift 2941번

// MARK: - 2941번
import Foundation
var input = readLine()!
let croatia: [String] = ["c=", "c-", "dz=", "d-", "lj", "nj", "s=", "z="]

for ch in croatia {
    input = input.replacingOccurrences(of: ch, with: "a")
}

var count: Int = input.count

print(count)

 

---

백준 Swift 1439번

// MARK: - 1439번
let S = Array(readLine()!).map{String($0)}
var countZero: Int = 0 // 0으로 바꾸는 횟수
var countOne: Int = 0 // 1로 바꾸는 횟수
var beforeChar = S.first!

if beforeChar == "0" {
    countOne += 1
}
else {
    countZero += 1
}

for ch in S {
    if ch != beforeChar {
        
        switch ch {
        case "0":
            countOne += 1
        case "1":
            countZero += 1
        default:
            print("default 없음.")
        }
        
        beforeChar = ch
    }

}

print(min(countZero, countOne))

 

---

백준 Swift 1789번

// MARK: - 1789번
let S = Int(readLine()!)!
var sum: Int = 0
var i: Int = 0

while sum <= S {
    i += 1
    sum += i
}

print(i - 1)

 

---

백준 Swift 4796번

// MARK: - 4796번
var caseCount: Int = 0

while true {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (L, P, V) = (input[0], input[1], input[2]) // V일짜리 휴가에서, 연속하는 P일 중, L일동안만 사용할 수 있다.
    
    if L == 0 && P == 0 && V == 0 {
        break
    }
    var day: Int = (V / P) * L // 최대 며칠
    
    if (V % P) != 0 { // 나머지가 있으면,
        if (V % P) <= L { // 남은 게 L일보다 작으면,
            day += (V % P)
        }
        else { // L일이 더 크면,
            day += L
        }
    }
    
    caseCount += 1
    print("Case \(caseCount): \(day)")
    
}

 

---

백준 Swift 9012번

// MARK: - 9012번
let T = Int(readLine()!)!

for _ in 0..<T {
    let input = readLine()!.map{String($0)}.map{String($0)}
    var stack: [String] = []
    var answer = ""
    
    for ch in input {
        if ch == "(" {
            stack.append(ch)
        }
        else if ch == ")" {
            if stack.isEmpty { // 비어있으면, 애초에 불가능.
                answer = "NO"
                break
            }
            else { // 비어 있진 않은데,
                if stack.last == "(" { // 마지막이 왼쪽괄호면 팝.
                    stack.removeLast()
                }
//                else if stack.last == ")" { // 마지막이 오른쪽괄호면,
//                    answer = "NO"
//                    break
//                }
            }
        }
    }
    
    if stack.isEmpty && answer != "NO" {
        answer = "YES"
    }
    else {
        answer = "NO"
    }
    
    print(answer)
}

 

---

백준 Swift 2164번

// MARK: - 2164번
class Deque<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init (_ queue: [T]) {
        self.enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
    
}

let T = Int(readLine()!)!
var cards: [Int] = []

for i in stride(from: T, to: 0, by: -1) {
    cards.append(i)
}

var myDeq = Deque<Int>(cards)

while myDeq.count > 1 {
    myDeq.popLast()
    myDeq.pushFirst(myDeq.popLast())
}


print(myDeq.popLast())

 

---