4-alstjr7437

[alstjr7437]

🔗 문제 링크

후보 추천하기

다시 그 기간이니 문제를 들고왔습니다!(정치 포스터는 논란이 생길 것 같아서)

✔️ 소요된 시간

25분

✨ 수도 코드

문제는 단순 구현이였습니다!!

1. 이미 있는 후보면 추천수 추가
2. 추천을 받는데 자리가 비어 있으면 그냥 넣기
3. 자리가 없으면 추천수가 낮은 사람 지우기
4. 만약 추천수가 같으면 제일 오래된 사람 지우기

위 4개의 로직만 생각하면 됐습니다.

---

그래서 단순하게 위 로직 순서대로 넣어줬습니다!

1. recommend 모두 반복문 돌기

2. 이미 result에 존재?

• 추천수 증가

3. 칸 수 부족?

• 후보에 넣기

4. 칸 수가 없으면?

• 추천 수 제일 낮은 값 뽑아내기
• 추천 수가 같은게 있으면? time이 제일 오래된거 뽑아내기

5. 마지막에 sort해서 결과 출력하기

위 로직대로 흘러갔습니다!!
아마 아래 정답 코드를 보시면 이해가 편하실꺼에요!(주석도 달아놨습니다!)

정답 코드

let N = Int(readLine()!)!
let totalCount = Int(readLine()!)!
let recommend = readLine()!.split(separator: " ").map { Int(String($0))! }

var result: [Int: (recommendCount: Int, time: Int)] = [:]
var currentTime = 0

for student in recommend {
    // 이미 후보에 존재
    if result[student] != nil {
        result[student]!.recommendCount += 1
    } else {
        // 후보 칸이 비어 있으면
        if result.count < N {
            result[student] = (1, currentTime)
        } else {
            // 비어 있지 않으면
            let removeValue = result.min {
                // 추천 수가 같으면 시간이 제일 오래된거 리턴
                if $0.value.recommendCount == $1.value.recommendCount {
                    return $0.value.time < $1.value.time
                }
                // 추천 수가 제일 작은거 리턴
                return $0.value.recommendCount < $1.value.recommendCount
            }!.key
            
            // 이미 존재하는 후보를 없애고 새 후보를 넣기
            result.removeValue(forKey: removeValue)
            result[student] = (1, currentTime)
        }
    }
    currentTime += 1
}

print(result.keys.sorted().map { String($0) }.joined(separator: " "))

📚 새롭게 알게된 내용

딕셔너리 안에 set을 넣어서 변수명을 지어서 작성하니 문제를 풀때 확실히 가독성도 좋고 이해도 편하더라구요!!

저도 처음에는 그냥 var result: [Int: (Int, Int)] = [:]으로 풀었다가 리팩토링을 해줬습니다!

이전

var result: [Int: (Int, Int)] = [:]

if $0.value.0== $1.value.0 {
    return $0.value.1 < $1.value.1
}

이후

var result: [Int: (recommendCount: Int, time: Int)] = [:]

if $0.value.recommendCount == $1.value.recommendCount {
    return $0.value.time < $1.value.time
}

[sep037]

은 머

은근 머리 아픈 문제였음

사진 처럼 매번 초기화 해주려고 하다가 어차피 배열에서 나가면 다 상관 없다는 걸 문제 풀다가 깨달았습니다 ..~

//
//  main.swift
//  1713
//
//  Created by Seungeun Park on 5/13/25.
//

import Foundation

let picturelimit = Int(readLine()!)!
let recommendCount = Int(readLine()!)!

struct Candidate {
    var num : Int
    var votes : Int
    var time : Int = 0
}

var time = 0

var candidateArray : [Candidate] = []
let recommendations = readLine()!.split(separator: " ").map { Int($0)! }

for candidateNum in recommendations {
    time += 1 // 일단 시간은 흘러가니까 ..
    
    /*
     if 후보에 올라가있지 않으면 {
         if 사진틀이 비어있으면 or 자리가 있으면 {
             // 그냥 올리기
         } else {
             // 가장 적게 추천받은 사람 제거하고 새 후보 올리기
         }
     } else {
         // 이미 올라가 있으면 투표 수만 올리기
     }
     */
    
    if let index = candidateArray.firstIndex(where: {$0.num == candidateNum}) { // 해당 후보 번호가 있는 인덱스 확인
        candidateArray[index].votes += 1 // 이미 올라가 있으면 수만 올리기
    } else { // 올라가있지 않으면
        if candidateArray.count < picturelimit { // 자리 있으면 그냥 추가
            candidateArray.append(Candidate(num: candidateNum, votes: 1, time: time))
        } else { // 자리가 없으면 비교해주기
            candidateArray.sort { // 추천 수 같으면
                if $0.votes == $1.votes {
                    return $0.time < $1.time // 시간으로 비교
                }
                return $0.votes < $1.votes // 아니면 추천 수로 비교
                }
            candidateArray.removeFirst()
            candidateArray.append(Candidate(num: candidateNum, votes: 1, time: time))
            }
            
        }
        
    }
    
let result = candidateArray.map { $0.num }.sorted() // 후보 번호 오름차순 !
print(result.map { String($0) }.joined(separator: " "))
    

[giljihun]

전체 로직은 동일한 것 같네요~

/* MARK: - SOLUTION
 
 현재까지 추천 받은 횟수가 가장 적은 학생의 사진을 삭제하고,
 그 자리에 새롭게 추천받은 학생의 사진을 게시.
 (2명 이상이면, 가장 게시된 지 오래된 사진 삭제)
 (이 경우, 추천받은 횟수는 0으로 초기화됨.)

 종 후보의 학생 번호를 증가하는 순서대로 출력
 
 1. 입력
 2.
    - 딕셔너리로 추천횟수, 순서를 관리.
    - 제거는 추천 횟수가 가장 낮은놈 OUT (동표 시, 순서가 젤 빠른놈)
 */

import Foundation


// MARK: - 입력
guard let input = readLine(),
      let N = Int(input),
      (1...20).contains(N) else { exit(0) }

guard let votingCnt = Int(readLine() ?? "") else { exit(0) }

if votingCnt == 0 {
    exit(0)
}

guard let votingPapers = readLine()?.split(separator: " ").compactMap({ Int($0) }) else { exit(0) }

// MARK: - 후보 등록 로직
var candidates: [Int: (votedCnt: Int, order: Int)] = [:]
var order = 1

votingPapers.forEach {
    addCandidate($0)
}

// MARK: - 출력
print(candidates.keys.sorted().map { String($0) }.joined(separator: " "))

// MARK: - 함수

// 후보 등록 함수
func addCandidate(_ candidate: Int) {
    if let _ = candidates[candidate] {
        votingCandidate(candidate)
        return
    }

    if candidates.count == N {
        delCandidate()
    }

    candidates[candidate] = (1, order)
    order += 1
}

// 투표 받은 횟수 증가
func votingCandidate(_ candidate: Int) {
    candidates[candidate]!.votedCnt += 1
}

// 후보자 제거
func delCandidate() {
    let minVote = candidates.values.map { $0.votedCnt }.min()
    let leastVoted = candidates.filter { $0.value.votedCnt == minVote }
    if let target = leastVoted.min(by: { $0.value.order < $1.value.order }) {
        candidates.removeValue(forKey: target.key)
    }
}

조건이 많은 구현문제는
갠적으로 더 코드를 깔끔하게 짜려고 하는 것 같다고 느꼈습니다.
그래야 예외처리할 부분도 더 보이고 하는 것 같아요.
깔끔한진 모르겠지만요..

이번 문제에서 계속 1%에서 오류가 떠서... 에러잡느라 조금 시간이 걸렸는데
정말 별거 아닌데, 치명적인 문제였어요!

var candidates: [Int: (votedCnt: Int, order: Int)]

이렇게 위 코드처럼 후보자 딕셔너리를 구성해야하는데

var candidates: [String: (votedCnt: Int, order: Int)]

위 코드처럼 후보자를 String으로 선언해놓고... 디버깅하고 있었어요..

이렇게하면 출력부에서 예를들어 후보자가 10, 2 였다면
문제 조건에 따라 2 10 으로 출력이 되어야하는데..
String을 정렬해봤자.. 10 2 로 나오는 것이죠..

반례를 찾아서 다행이고.. 앞으로는 타입을 좀 더 신경써야겠다고 느꼈습니다.

[giljihun]

guard let votingCnt = Int(readLine() ?? "") else { exit(0) }

if votingCnt == 0 {
    exit(0)
}

전 자꾸 에러떠서
"설마 무슨 투표자 0명! 이런 처리를 해야하나? ㅠㅠ" 하면서
여기에 이런 조건도 추가하고 그랬네요 ㅋㅋㅋ

[giljihun]

var candidates: [Int: (votedCnt: Int, order: Int)] = [:]
var order = 1

currentTime 변수명 좋네요, 저는 order(순서)로 했슴다.

[bishoe01]

order 좋네요 저는 time? 하려다가 와닿지않아서 number해줬는데, (저는 기호~번을 symbol로 해줬습니다.) 헷갈리더라구요

[sep037]

또 approve해서 죄송 ㅠ ..

[YooGyeongMo]

let n = Int(readLine()!)!
let m = Int(readLine()!)!
let recommend = readLine()!.split(separator:" ").map { Int(String($0))! }

func photoFrames(frameCount n: Int, recommendationList nums: [Int]) -> [Int] {
    var stack: [Int] = []
    var count = Array(repeating: 0, count: 101)
    
    for student in nums {
        if stack.contains(student) {
            count[student] += 1
            continue
        }

        if stack.count == n {
            // 추천 수가 가장 적은 사람 찾기
            let minVote = stack.map { count[$0] }.min()!
            
            // 가장 먼저 걸린 학생 중 추천 수 == min 인 사람 제거
            for old in stack {
                if count[old] == minVote {
                    count[old] = 0
                    if let idx = stack.firstIndex(of: old) {
                        stack.remove(at: idx)
                    }
                    break
                }
            }
        }

        // 스택처럼 뒤에 추가
        stack.append(student)
        count[student] = 1
    }

    return stack.sorted()
}

let result = photoFrames(frameCount: n, recommendationList: recommend)
print(result.map { String($0) }.joined(separator: " "))

stack 으로 짜보았습니다.

[YooGyeongMo]

딕셔너리의 키와 벨류 사용하셔서 푸셧네요.
처음에는

struct Candidate {
    let number: Int
    var votes: Int
    var time: Int
}

struct로 상태관리하려고 했었는데 역시 알고리즘에서는 딕셔너리가 짜세군요.

사실 저는 문제 보자마자 stack구조가 떠올라서 바로 stack구조를 짜보았습니다.

[bishoe01]

저도 보고 struct, class 써보고 싶어서 억지로 써보다가 좀 오래걸리고 복잡해진 것 같아요. 정말 알고리즘은 dictionary가 많은걸 할 수 있게 해주네요 ㄷㄷ..
dictionary 구조를 key value 쓰면서 엄청 깔끔하게 잘 푸신것같습니다... 배워가요

[MuchanKim]

전 뭔가 구현 문제가 재밌기도하고 도움도 많이되는 것 같네요..ㅎㅎ

다른분들 코드랑 비교해서 보는데 크게 다른점은 전 오래된 사진을 구분하기위한 변수를 사용하지 않고 인덱스로 판별해줬어요. 근데 다른분들처럼 명시적으로 처리해주는게 가독성 면에서나 성능면에서도 좋다고 느껴지네요. 고생하셨슴다!

import Foundation

struct Candidate {
   let studentNumber: Int
   var recommendCount: Int
   
   mutating func incrementRecommend() {
       recommendCount += 1
   }
   
   mutating func resetRecommend() {
       recommendCount = 0
   }
}

var candidates: [Candidate] = []
var res: [Int] = []

// input
let N = Int(readLine()!)!
let recommandCount = Int(readLine()!)!
let recommandNumbers: [Int] = readLine()!.split(separator: " ").map { Int($0)! }

for studentNumber in recommandNumbers {
   // 이미 게시된 학생인지 확인
   if let index = candidates.firstIndex(where: { $0.studentNumber == studentNumber }) {
       // 이미 게시된 경우 추천 횟수만 증가
       candidates[index].incrementRecommend()
   } else {
       // 새로운 학생인 경우
       if candidates.count < N {
           // 사진틀이 비어있는 경우
           candidates.append(Candidate(studentNumber: studentNumber, recommendCount: 1))
       } else {
           // 사진틀이 가득 찬 경우
           // 추천 횟수가 가장 적고, 가장 오래된 후보 찾기
           let minRecommend = candidates.min { $0.recommendCount < $1.recommendCount }!.recommendCount
           if let index = candidates.firstIndex(where: { $0.recommendCount == minRecommend }) {
               // 가장 오래된 후보 제거
               candidates.remove(at: index)
               // 새로운 후보 추가
               candidates.append(Candidate(studentNumber: studentNumber, recommendCount: 1))
           }
       }
   }
}

res = candidates.map { $0.studentNumber }.sorted()

print(res.map { String($0) }.joined(separator: " "))

[MuchanKim]

최근에 swifty하게 코드 쓰는 법에대해 고민하고 있습니다. 옵셔널 nil 값을 체크해주는 체이닝이 있는데 저도 킨더처럼 익숙한 방법만 쓰게 되더라고요. 체이닝을 써서 아래처럼 간결하게 쓸 수도 있겠네요!

예시

// 기존
if result[student] != nil {
    result[student]!.recommendCount += 1
}

// 체이닝
result[student]?.recommendCount += 1

[giljihun]

이거 짱짱 swifty ㅇㅈ합니다.

[MuchanKim]

딕셔너리로 하셨군요.

[bishoe01]

문제보고 좀 swift스럽게 풀려고 이렇게 좀 특이하게 풀어봤습니다.

Candidate는 struct으로 구현해줬어요. 좀 구조가 단순하기돟고 좋아요 추가정도밖에 없어서 struct로 해줬고,
Gallery는 class로 구현해줬는데, 내부 상태 lines를 계속 바꿔줄 것 같아서 class로 뒀습니다.
이 두가지를 좀 명확하게 뭐가 좋다하고 구분하는게 있는지.. 궁금하네요.. 링고랑 살짝 얘기했을때는 struct로 하는걸 좀 지향하라고 하시긴 하셨는데, 좀 더 알아봐야할 것 같습니다...

import Foundation

struct Candidate: Equatable {
    var symbol: Int
    var like: Int = 1
    let idx: Int

    mutating func updateLike() {
        like += 1
    }

    // 불린순서
//    mutating func updateIdx(_ idx: Int) {
//        self.idx = idx
//    }
}

class Gallery {
    var limit: Int
    var lines = [Candidate]()

    init(_ limit: Int) {
        self.limit = limit
        self.lines = []
    }

    // 퇴출제도
    func out() {
        let minLike = lines.min(by: {
            if $0.like == $1.like {
                return $0.idx < $1.idx
            }
            return $0.like < $1.like
        })!

        lines.remove(at: lines.firstIndex(where: { $0.symbol == minLike.symbol })!)
    }

    func append(_ candidate: Candidate) {
        if let alreadyIdx = lines.firstIndex(where: { $0.symbol == candidate.symbol }) {
            lines[alreadyIdx].updateLike()
        }
        else {
            // 꽉 차면 퇴출 
            if lines.count == limit {
                out()
            }
            // 아직 꽉 차지 않았다면 ? 걍 추가
            lines.append(candidate)
        }
        
    }

    func answer() {
        lines.sort { $0.symbol < $1.symbol }
//        print(lines)
        lines.map { $0.symbol }.forEach {
            print($0, terminator: " ")
        }
    }
}

func solution(_ n: Int, _ arr: [Int]) {
    let gallery = Gallery(n)

    for (idx, item) in arr.enumerated() {
        gallery.append(Candidate(symbol: item, idx: idx))
    }
//    gallery.out()
    gallery.answer()
}

---

계속 정답 20%에서 틀렸습니다가 무한으로 등장

append 함수에서 문제가 있었음. 그냥 꽉 안찼으면 생각없이 append를 해주고 있다보니, 중복이 막들어감 !!!

기존 append

    func append(_ candidate: candidate) {
        // 아직 꽉 차지 않았다면 ? 걍 추가
        if lines.count < limit {
            lines.append(candidate)
        } else {
            // 만약에 이미 있는 애라면 !
            if let alreadyIdx = lines.firstIndex(where: { $0.symbol == candidate.symbol }) {
                lines[alreadyIdx].updateLike()
            } else {
                // 이미 있는 애가 없으면 후보 교체
                out()
                lines.append(candidate)
            }
        }
    }

변경후 append

 func append(_ candidate: Candidate) {
        if let alreadyIdx = lines.firstIndex(where: { $0.symbol == candidate.symbol }) {
            lines[alreadyIdx].updateLike()
        }
        else {
            // 꽉 차면 퇴출 
            if lines.count == limit {
                out()
            }
            // 아직 꽉 차지 않았다면 ? 걍 추가
            lines.append(candidate)
        }        
    }

---

풀이

• 원래 최근에 추천못받은애가 탈락하는지알고, updateIdx를 사용하다가 파기했습니다.
• 후보들이 모여있는 공간을 Gallery로 class를 두고, 여기에서 후보들을 추가하고.. 퇴출하는 등 관리를 해줬습니다.
• 코드 구조자체는 class와 struct만 보시면 사실 그냥 append 한개라서 이해하기 쉬우쉴 것 같아요

append

1. 이미 Gallery의 lines에 있는 후보면 좋아요 추가
2. 꽉 차면 퇴출
3. 꽉 차지 않았다면 걍 추가

out

1. 좋아요 수 비교
2. 그 다음으로 idx 비교 (게시된 시간 순)

answer

• 백준에서 원하는 형태 정답 출력

당장 생각나는 개선점

아마 지금 idx로 해주고 있는거를 idx 입력받지말고, Gallery안에서 활동하는 변수로 append해줄때마다 +=1 해주면 더 가시성있게 구성이 될 것 같네요

[alstjr7437]

오호 핀 리뷰를 엄청 자세하게 그리고 Swift스럽게 푸셨네요 잘봤습니다!!