모의고사

import Foundation

func answerCountOfOne(_ n: Int, _ answers: [Int]) -> Int {
    var result = 0  // 정답 개수
    
    for i in 1...n {
        var mark = -1   // 체크한 정답
        
        if i % 5 == 0 {
            mark = 5
        } else {
            mark = i
        }

        if answers[mark-1] == mark {
            result += 1
        }
    }
    
    return result
}

func answerCountOfTwo(_ n: Int, _ answers: [Int]) -> Int {
    var markSheet = [Int]()
    for i in 1...n/2+1 {
        markSheet.append(2)

        var mark = -1
        if i % 5 == 0 {
            mark = 5
        } else {
            mark = i
        }
        markSheet.append(mark)
    }

    var result = 0
    for i in 0..<n {
        if markSheet[i] == answers[i] {
            result += 1
        }
    }
    
    return result
}

func answerCountOfThree(_ n: Int, _ answers: [Int]) -> Int {
    var markSheet = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
    
    while true {
        if markSheet.count < n {  // 짧으면 답안 추가하기
            markSheet += markSheet
        } else {
            break
        }
    }

    var result = 0
    for i in 0..<n {
        if answers[i] == markSheet[i] {
            result += 1
        }
    }
    
    return result
}

func solution(_ answers:[Int]) -> [Int] {
    let n = answers.count    // 문제 개수
    
    var scores = [Int]()    // 맞은 개수
    
    // 1번 수포자 방식
    let scoreOne = answerCountOfOne(n, answers)
    scores.append(scoreOne)
    
    // 2번 수포자 방식
    let scoreTwo = answerCountOfTwo(n, answers)
    scores.append(scoreTwo)
    
    // 3번 수포자 방식
    let scoreThree = answerCountOfThree(n, answers)
    scores.append(scoreThree)
    
    let maxVal = max(max(scoreOne, scoreTwo), scoreThree)
    
    var result = [Int]()
    for i in 1...3 {
        if maxVal == scores[i] {
            result.append(i)
        }
    }
    
    return result
}

정확성: 50.0 😂
합계: 50.0 / 100.0 😂

markSheet으로 답안을 다 작성하는 방식으로 만들었는데
다른 사람들의 풀이를 보니 답안을 뭉텅이로 가져다 쓰더라

[1, 2, 3, 4, 5]
[2, 1, 2, 2, 2, 3, 2, 4, 2, 5]
[3, 3, 1, 1, 2, 2, 4, 4, 5, 5]

import Foundation

func solution(_ answers:[Int]) -> [Int] {
    let hater1 = [1, 2, 3, 4, 5]
    let hater2 = [2, 1, 2, 2, 2, 3, 2, 4, 2, 5]
    let hater3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]

    var scores = [0, 0, 0]
    
    for i in 0..<answers.count {

        if answers[i] == hater1[i % hater1.count] {
            scores[0] += 1
        }
        if answers[i] == hater2[i % hater2.count] {
            scores[1] += 1
        }
        if answers[i] == hater3[i % hater3.count] {
            scores[2] += 1
        }
    }

    let maxVal = scores.max()

    var result = [Int]()
    for i in 0..<scores.count {
        if scores[i] == maxVal {
            result.append(i+1)
        }
    }

    return result
}

정확성: 64.3 😂
합계: 64.3 / 100.0 😂

모르겠다...
테스트케이스 1, 6, 10, 11, 13을 통과하지 못했었는데
let hater2 = [2, 1, 2, 2, 2, 3, 2, 4, 2, 5] 가 아니라
let hater2 = [2, 1, 2, 3, 2, 4, 2, 5] 이거였다...

---

소수 찾기

스위프트는 순열과 조합이 너무 까다롭다...😂
https://gimjinging.tistory.com/133

1. 숫자로 만들수 있는 모든 조합을 구한다
   여기서 완전탐색을 쓴다는 건데...
   depth? digit? 같은 변수의 값이 2라고 하면
   1과 7이 있으면 두 자리수 17, 71 이렇게 구할 수 있는 거다
   21과 12가 다르므로 순서가 있는 permutation(순열)에 해당한다
   순열과 조합에 대한 라이브러리가 없어서 환장할 노릇이다
   생각나는 완전탐색 방법으로는 백트래킹방식과 DFS이 있는데 백트래킹방식이 적합할 거라고 생각했다
2. 011과 11은 같은 수로 처리하고 중복되는 숫자를 제거하는 거기 때문에
   Set를 쓰면 좋을 거라고 생각했다
   세트 타입은 아래와 같은 형식을 사용한다는 점이 특이하다

var setArr = Set<Int>() = []
setArr.insert(값)

3. 소수 찾기 하면 빼놓을 수 없는 부분이 바로 에라토스테네스의 체라는 알고리즘이다
   골자는 전체 범위가 아니라 제곱근한 범위만큼이 특정 수로 나눠지는지 체크하는 것이다

https://gimjinging.tistory.com/133