[정기적 문제 풀이 추가 PR] 2022.03.30 정기적 문제 풀이 추가합니다!

README.md

@@ -8,6 +8,7 @@
 ## 😁 **도움이 되셨다면** 오른쪽 상단 ↗ 의 ⭐️ **Star를 클릭**해 이 프로젝트를 응원해주세요!
 
 ## 풀이 현황
+
 풀이 완료로 표시된 Level의 폴더에 포함되지 않은 답안이 있다면
 
 - [Issues](https://github.com/codeisneverodd/programmers-coding-test/issues) 에 제보해주세요. `New issue`를 누르고 제목과 내용을
@@ -25,9 +26,11 @@
 - 풀이 문제 수: 43문제(2022.03.28)
 - 풀이 완료 예상 시점: 2022년 4월 중
 
-### Level 3
+### Level 3 👨🏻‍💻(풀이 중..)
 
-풀이 완료 예상 시점: 2022년 8월 중
+- 전체 문제 수: 52문제
+- 풀이 문제 수: 5문제(2022.03.24)
+- 풀이 완료 예상 시점: 2022년 8월 중
 
 ### Level 4
 

level-2/프린터.js

@@ -19,7 +19,7 @@ function solution(priorities, location) {
     return answer;
 }
 
-//정답 2 - codisneverodd
+//정답 2 - codeisneverodd
 function solution(priorities, location) {
     var answer = 0;
     let documents = priorities.map((priority, documentLocation) => [documentLocation, priority])
@@ -46,9 +46,9 @@ function solution(priorities, location) {
 //정답 3 - jaewon1676
 function solution(priorities, location) {
     var answer = 0;
-     while(true){
+    while (true) {
 
-        if (priorities[0] < Math.max(...priorities)){
+        if (priorities[0] < Math.max(...priorities)) {
             if (location - 1 < 0) location = priorities.length
             priorities.push(priorities.shift())
             location--;
@@ -64,4 +64,53 @@ function solution(priorities, location) {
 
     }
     return answer
+}
+
+//정답 4 - codeisneverodd
+//shift를 사용하지 않고 queue를 구현한 풀이를 추가합니다.
+function solution(priorities, location) {
+    let answer = 0;
+    const printer = new Queue;
+    priorities.forEach((priority, index) => {
+        printer.enqueue([priority, index])
+    })
+    while (printer.size() > 0) {
+        const check = printer.dequeue()
+        const countHigherPriority = printer.queue.filter(x => x[0] > check[0]).length
+        if (countHigherPriority > 0) {
+            printer.enqueue(check)
+        } else {
+            answer += 1
+            if (check[1] === location) break
+        }
+
+    }
+    return answer;
+}
+
+class Queue {
+    constructor() {
+        this.queue = []
+        this.front = 0
+        this.rear = 0
+    }
+
+    enqueue(value) {
+        this.queue[this.rear++] = value
+    }
+
+    dequeue() {
+        const value = this.queue[this.front]
+        delete this.queue[this.front]
+        this.front += 1
+        return value
+    }
+
+    peek() {
+        return this.queue(this.front)
+    }
+
+    size() {
+        return this.rear - this.front
+    }
 }

level-2/후보키.js

@@ -0,0 +1,50 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//완벽한 정답이 아닙니다.
+//정답 1 - codeisneverodd
+function solution(relation) {
+    //1. 가능한 조합을 1개~Attribute개수 만큼 찾는다.
+    //2. 해당 개수의 조합이 키가 될 수 있는지 검사하고, 가능하면 후보키에 추가한다.
+    //3. 단 추가하려고 할 때, 후보키에 있는 값이 자신의 부분 집합이 될 수 있으면 추가하지 않는다.
+    const keys = []
+    const totalAttrCount = relation[0].length
+    const indexList = Array.from(Array(totalAttrCount), (x, index) => index) // [0,1,2,3 ... totalAttrCount-1]
+
+    //Fn for 2. 해당 조합으로 각 row의 attribute를 모았을 때 중복이 있는지를 반환하는 함수
+    const isUnique = (relation, attrIndexComb) => {
+        let result = Array.from(Array(relation.length), x => '')
+        for (const attrIndex of attrIndexComb) {
+            relation.forEach((row, rowIndex) => result[rowIndex] += row[attrIndex]) //Set를 이용해 중복 검사를 하기 위해 result에 string으로 넣음.
+        }
+        return result.length === [...new Set(result)].length
+    }
+
+    //Fn for 3. keys에 현재 구한 검사할 조합의 부분집합이 존재하는지 반환, 단 keys에 들어있는 각 조합의 크기는 현재 검사할 조합의 크기보다 작다.
+    const isMinimal = (attrComb) => {
+        for (const key of keys) if (key.every(attr => attrComb.includes(attr))) return false
+        return true
+    }
+
+    //가능한 모든 조합을 검사
+    for (let attrCount = 1; attrCount <= totalAttrCount; attrCount++) {
+        const combinations = getCombinations(indexList, attrCount)
+        for (const attrComb of combinations) {
+            if (isMinimal(attrComb) && isUnique(relation, attrComb)) keys.push(attrComb)
+        }
+    }
+
+    return keys.length
+}
+
+//Fn for 1. 조합을 반환하는 함수
+const getCombinations = (array, selectNumber) => {
+    const result = [];
+    if (selectNumber === 1) {
+        return array.map((element) => [element]);
+    }
+    array.forEach((fixed, index, origin) => {
+        const restCombinations = getCombinations(origin.slice(index + 1), selectNumber - 1);
+        const attached = restCombinations.map((restCombination) => [fixed, ...restCombination]);
+        result.push(...attached);
+    });
+    return result;
+}

level-3/가장-먼-노드.js

@@ -0,0 +1,23 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//완벽한 정답이 아닙니다.
+//정답 1 - codeisneverodd
+function solution(n, edge) {
+    const graph = Array.from(Array(n + 1), () => [])
+    for (const [src, dest] of edge) {
+        graph[src].push(dest)
+        graph[dest].push(src)
+    }
+    const distance = Array(n + 1).fill(0)
+    distance[1] = 1
+    const toBeSearched = [1]
+    while (toBeSearched.length > 0) {
+        const src = toBeSearched.shift()
+        for (const dest of graph[src]) {
+            if (distance[dest] === 0) {
+                distance[dest] = distance[src] + 1
+                toBeSearched.push(dest)
+            }
+        }
+    }
+    return distance.filter(x => x === Math.max(...distance))
+}

level-3/네트워크.js

@@ -0,0 +1,30 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//완벽한 정답이 아닙니다.
+//정답 1 - codeisneverodd
+function solution(n, computers) {
+    let answer = 0
+    const visited = new Array(n).fill(false)
+    const newNetwork = (startComputer) => {
+        //새로운 네트워크를 만들 시작 컴퓨터를 파라미터로 받는다.
+        const toBeVisited = [startComputer]
+        while (toBeVisited.length > 0) {
+            //시작 컴퓨터로부터 방문 가능한 컴퓨터를 모두 방문하며 해당 컴퓨터의 visited를 true로 바꾼다
+            const currentComputer = toBeVisited.pop()
+            visited[currentComputer] = true
+            for (let nextComputer = 0; nextComputer < n; nextComputer++) {
+                if (!visited[nextComputer] && computers[currentComputer][nextComputer]) {
+                    toBeVisited.push(nextComputer)
+                }
+            }
+        }
+    }
+
+    for (let startComputer = 0; startComputer < n; startComputer++) {
+        if (!visited[startComputer]) {
+            newNetwork(startComputer)
+            //새로운 네트워크를 생성할 때마다 정답을 1 증가시킨다.
+            answer++
+        }
+    }
+    return answer
+}

level-3/베스트앨범.js

@@ -0,0 +1,48 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//완벽한 정답이 아닙니다.
+//정답 1 - codeisneverodd
+function solution(genres, plays) {
+    var answer = [];
+    const songs = []
+    const genreSumHash = {}
+    const genreSumArr = []
+
+    //고유번호, 장르, 플레이수를 담은 songs
+    genres.forEach((genre, id) => {
+        songs.push({id: id, genre: genre, play: plays[id]})
+        genreSumHash[genre] = genreSumHash[genre] === undefined ? plays[id] : genreSumHash[genre] + plays[id]
+    })
+
+    //장르별 플레이수 합으로 정렬하기 위해 생성한 배열 genreSumArr
+    for (const genre in genreSumHash) genreSumArr.push([genre, genreSumHash[genre]])
+    genreSumArr.sort((a, b) => b[1] - a[1])
+
+    //각 장르안에서 각 노래의 play수가 높은 순으로 정렬하고 앞에서부터 2개까지 정답에 고유번호를 push
+    for (const genre of genreSumArr) {
+        const sorted = songs.filter(song => song.genre === genre[0]).sort((a, b) => b.play - a.play)
+        for (let i = 0; i < 2 && i < sorted.length; i++) answer.push(sorted[i].id)
+    }
+    return answer;
+}
+
+//정답 2 - codeisneverodd
+//Map과 고차함수를 적극적으로 이용한 풀이
+function solution(genres, plays) {
+    const genreMap = new Map(); // {genre:{totalPlay:number, songs:[{play:number, id:number}, ...]}
+    genres
+        .map((genre, id) => [genre, plays[id]])
+        .forEach(([genre, play], id) => {
+            const data = genreMap.get(genre) || {totalPlay: 0, songs: []}
+            genreMap.set(genre, {
+                totalPlay: data.totalPlay + play,
+                songs: [...data.songs, {play: play, id: id}]
+                    .sort((a, b) => b.play - a.play)
+                    .slice(0, 2)
+            })
+        })
+
+    return [...genreMap.entries()] //entries => [[genre, {totalPlay, songs}], ...]
+        .sort((a, b) => b[1].totalPlay - a[1].totalPlay)
+        .flatMap(item => item[1].songs) // [[songs], [songs]] => [songs, songs]
+        .map(song => song.id)
+}

level-3/여행경로.js

@@ -0,0 +1,24 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//완벽한 정답이 아닙니다.
+//정답 1 - codeisneverodd
+function solution(tickets) {
+    const routes = [] //최종 가능 루트들을 담을 배열
+    const makeRoutes = (currentDepart, remainTickets, currentRoute) => {
+        //현재 출발지, 남은 티켓들, 현재 까지 만든 루트를 기반으로 경로를 만들어 가는 재귀 함수
+        if (remainTickets.length > 0) {
+            remainTickets.forEach(([depart, nextDepart], index) => {
+                if (depart === currentDepart)
+                    //현재 출발지와 같은 출발지를 가진 티켓이 있다면, 해당 티켓을 사용하고 해당 티켓의 도착지를 다음 출발지로 지정
+                    makeRoutes(
+                        nextDepart,
+                        [...remainTickets.slice(0, index), ...remainTickets.slice(index + 1)],
+                        [...currentRoute, currentDepart])
+            })
+        } else {
+            //티켓을 모두 사용하면 최종 가능 루트에 포함
+            routes.push([...currentRoute, currentDepart])
+        }
+    }
+    makeRoutes("ICN", tickets, [])
+    return routes.sort()[0]
+}

level-3/입국심사.js

@@ -0,0 +1,19 @@
+//https://github.com/codeisneverodd/programmers-coding-test
+//완벽한 정답이 아닙니다.
+//정답 1 - codeisneverodd
+function solution(n, times) {
+    //최소로 걸릴 수 있는 시간 left, 최대로 걸릴 수 있는 시간 right
+    let [left, right] = [1, Math.max(...times) * n]
+    while (left <= right) {
+        const mid = Math.floor((left + right) / 2)
+        const sum = times.reduce((acc, time) => acc + Math.floor(mid / time), 0)
+        //sum은 mid 시간 동안 처리 할 수 있는 사람의 수
+        if (sum < n) {
+            left = mid + 1
+        } else {
+            right = mid - 1
+        }
+    }
+    // left 가 right를 넘어갔다는 것은 left가 n보다 크거나 같아져서 n명을 수용할 수 최소값이 되있다는 것이다.
+    return left;
+}