Merge pull request #8 from codeisneverodd/codeisneverodd

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

Author: codeisneverodd

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;
+}