Merge branch 'main' into codeisneverodd

Author: codeisneverodd

level-1/3진법-뒤집기.js

@@ -24,4 +24,11 @@ const decimalToTernaryReversed = num => {
     }
     ternary += num.toString()
     return ternary
+}
+
+//정답 3 - jaewon1676
+function solution(n) {
+    var answer = n.toString(3).split('').reverse().join('')
+
+    return parseInt(answer, 3)
 }

level-1/[1차]-비밀지도.js

@@ -33,4 +33,24 @@ function solution(n, arr1, arr2) {
     }
     answer = answer2D.map(row => row.join(''))
     return answer;
-}
+}
+
+//정답 3 - jaewon1676
+function solution(n, arr1, arr2) {
+    let answer = [];
+    for (let i=0; i<n; i++){
+        let temp = (arr1[i] | arr2[i]).toString(2)
+        let line = []; // 한 행의 모든 2진수 보관
+
+        for (let j=temp.length - n; j< temp.length; j++){
+            if (temp[j] == 1) {line.push('#')}
+            else {line.push(' ')}            
+        }
+        answer.push(line.join(''))
+    }
+    return answer
+}
+/* 풀이 과정
+1. 배열 arr1, arr2 을 2진수로 변한한다. 이 때, 하나라도 1일 시에는 1로 변환하고, 그렇지 않으면 0을 반환한다.
+2. 9번의 반복문을 행의 길이만큼 돌려 1이면 #, 그렇지 않으면 띄어쓰기를 push 해준다.
+3. 행의 배열의 원소를 join 메서드를 사용하여 문자열로 합친다.*/

level-1/로또의-최고-순위와-최저-순위.js

@@ -42,4 +42,42 @@ function hit(lottos, win_nums) {
     return result
 }
 
+// 정답 3 - jaewon1676
+function solution(lottos, win_nums) {
+    var answer = [];
+    const correct = lottos.filter(lotto => win_nums.includes(lotto)).length;
+    // lottos배열을 순회하며 당첨배열에 있는 수를 return 하고 총 개수를 correct에 저장
+    
+    const zeros = lottos.filter(lotto => lotto === 0).length;
+    // lottos배열을 순회하며 0인 총 개수를 zeros에 저장
+    
+    let min = 7-correct >= 6 ? 6 : 7-correct;
+    
+    let max = min-zeros < 1 ? 1 : min-zeros;
+    
+    answer = [max,min]
+    
+    return answer;
+}
 
+// 정답 4 - jaewon1676
+function solution(lottos, win_nums) {
+    var answer = [];
+    let max = 7;
+    let min = 7;
+    console.log(lottos)
+    console.log(win_nums)
+    for(let i=0; i<6; i++){
+        if (lottos.includes(win_nums[i])){
+            max--;
+        }
+    }
+    min = max;
+    for(let i=0; i<6; i++){
+        if (lottos[i] == 0) min--;
+    }
+    if (max == 7) max = 6
+    if (min == 7) min = 6
+    answer = [min, max]
+    return answer;
+}

level-1/숫자-문자열과-영단어.js

@@ -23,4 +23,23 @@ function solution(s) {
     }
     answer = Number(answerString)
     return answer;
+}
+
+//정답 3 - jaewon1676
+function solution(s) {
+    let answer = 0;
+    
+    s = s.replace(/zero/g, 0);
+    s = s.replace(/one/g, 1);
+    s = s.replace(/two/g, 2);
+    s = s.replace(/three/g, 3);
+    s = s.replace(/four/g, 4);
+    s = s.replace(/five/g, 5);
+    s = s.replace(/six/g, 6);
+    s = s.replace(/seven/g, 7);
+    s = s.replace(/eight/g, 8);
+    s = s.replace(/nine/g, 9);
+    
+    answer = Number(s);
+    return answer;
 }

level-1/신고-결과-받기.js

@@ -35,3 +35,35 @@ function solution(id_list, report, k) {
 
     return answer
 }
+
+//정답 2 - jaewon1676
+function solution(id_list, report, k) {
+    
+    let answer = new Array(id_list.length).fill(0)
+    let report_list = {} // 신고당한 ID
+    
+    // key, value 형식의 report_list 객체를 만든다.
+    id_list.map((user)=>{
+    report_list[user] = [] //key = userid , value = 빈 배열을 가지는 객체
+    })
+    // report_list { muzi: [], frodo: [], apeach: [], neo: [] }
+
+    // 유저가 신고한 ID를 report_list 객체에 넣어주기 위해 순회한다.
+    report.map((user)=>{
+        const [user_id, report_id] = user.split(' ') 
+        // report 값에서 띄어쓰기로 구분된 문자열을 자르고 user_id, report_id로 각각 넣어준다. 
+        if(!report_list[report_id].includes(user_id)){
+            report_list[report_id].push(user_id)
+        // 배열에 포함하는지 여부를 확인하여 포함하지 않을때 신고자의 이름을 추가하였다.
+        }     
+
+    })
+    for(const key in report_list){ // report_list의 index 순회
+        if(report_list[key].length >= k){
+            report_list[key].map((user)=>{
+                answer[id_list.indexOf(user)] += 1
+            })
+        }
+    }
+    return answer   
+}

level-1/신규-아이디-추천.js

@@ -44,4 +44,35 @@ function solution(new_id) {
             break
     }
     return answer
+}
+
+//정답 3 - jaewon1676
+function solution(new_id) {
+    // 1 소문자로 치환
+    let answer = new_id.toLowerCase()
+  
+    // 2 알파벳 소문자, 숫자, 빼기(-), 밑줄(_), 마침표(.)를 제외한 문자 제거.
+    .replace(/[^a-z0-9-_.]/gi, '')
+    
+    // 3 마침표(.)가 2번 이상 연속된 부분을 하나의 마침표(.)로 치환
+    .replace(/[.]{2,}/gi, '.')
+    
+    // 4 마침표(.)가 처음이나 끝에 위치하면 제거
+    .replace(/^[.]|[.]$/gi,'');
+    
+    // 5 빈 문자열이면 a 대입
+    if(answer==='') answer = 'a';
+    
+    // 6 length > 15이면 그 뒤의 문자들은 제거
+    if(answer.length > 15){
+        answer = answer.substring(0, 15);
+        // 마침표(.)가 끝에 위치하면 마침표(.)제거
+        answer = answer.replace(/[.]$/gi,'');
+    }
+    
+    // 7 length < 3이면 마지막 문자를 new_id의 길이가 3이 될 때까지 반복해서 끝에 붙임
+    while(answer.length < 3){
+        answer += answer[answer.length-1];
+    }
+    return answer;
 }

level-1/실패율.js

@@ -30,4 +30,44 @@ function solution(N, stages) {
     const sortedRate = rateNIndex.sort((a, b) => b[0] - a[0])
     answer = sortedRate.map(stage => stage[1])
     return answer;
-}
+}
+
+//정답 3 - jaewon1676
+function solution(N, stages) {
+    let map = Array.from(Array(N), () => Array(2).fill(0))
+    let answer = Array(N).fill(0, 0, N); // 스테이지별 탈락자 수
+    let rate = Array(N).fill(0, 0, N); // 스테이지별 실패율 
+    let count = 0;
+    
+    stages.sort(function(a, b){ return a - b}) // 난이도 오름차순 정렬
+    for (let i=1; i<=N; i++){
+        while(1){  // i 스테이지의 실패율 계산
+            if (stages[0] == i){
+                answer[i-1] += 1
+                count += 1
+                stages.shift();
+            }
+            else break;
+        }
+        rate[i-1] += answer[i-1]/(stages.length + count) // 실패율 계산
+        
+        count = 0
+        
+        map[i-1][0] = i;
+        map[i-1][1] = rate[i-1];
+        
+    }
+    map.sort((a, b) => b[1] - a[1]); // value값(실패율) 기준 내림차순정렬
+    let stack = [] // 답
+    for(let i=0; i<map.length; i++){
+        stack.push(map[i][0])
+    }
+
+    return stack
+}
+/* 풀이 과정
+1. 스테이지를 정렬 후 난이도 N과 같은 스테이지가 맨 앞에 있는지 찾아 찾으면 shift, 찾지 못하면 다음 난이도로 넘어간다.
+2. 실패율을 계산해주기 위해, 스테이지별 탈락자 수,스테이지별 실패율 배열을 생성하여 각각, 계산해준다.
+3. 계산 해준 값들을 2차원 배열 map 객체에 넣어준다. 2차원으로 한 이유는 index값과, 실패율 값을 같이 넣어 정렬 시에도 index값을 유지 하기 위해서.
+4. 실패율을 내림차순(같으면 스테이지가 낮은거부터 오름차순)으로 정렬하여 출력해준다.
+*/

level-1/완주하지-못한-선수.js

@@ -2,12 +2,64 @@
 //완벽한 정답이 아닙니다.
 //정답 1 - codeisneverodd
 function solution(participant, completion) {
-    var answer = '';
-    participant = participant.sort()
-    completion = completion.sort()
-    for (let i = 0, len = completion.length; i < len; i++) {
-        if (participant[i] !== completion[i]) return participant[i]
-    }
-    answer = participant[participant.length - 1]
-    return answer
-}
+	var answer = "";
+	participant = participant.sort();
+	completion = completion.sort();
+	for (let i = 0, len = completion.length; i < len; i++) {
+		if (participant[i] !== completion[i]) return participant[i];
+	}
+	answer = participant[participant.length - 1];
+	return answer;
+}
+
+//정답 2 - jaewon1676
+function solution(participant, completion) {
+	var answer = "";
+	for (let i = 0; i < participant.length; i++) {
+		for (let j = 0; j < completion.length; j++) {
+			if (participant[i] === completion[j]) {
+				console.log(participant, completion);
+				participant.splice(i, 1);
+				completion.splice(j, 1);
+				i--;
+				j--;
+				console.log(participant, completion);
+				break;
+			}
+		}
+	}
+
+	return participant[0];
+}
+
+//완벽한 정답이 아닙니다.
+//정답 3 - hyosung
+function solution(participant, completion) {
+	let answer = "";
+	// 2개 이상을 가진 특정값의 갯수 기록용 변수
+	let max = 0;
+	// 반복문 내부에서 set.has 를 사용하기 위해 Set 선언 (처음에는 Array.findIndex 를 사용)
+	const set = new Set([...completion]);
+	// 반복문 최적화 - 반복되던 연산 제거 (값 비교, length)
+	const length = participant.length;
+	for (let i = length; i--; ) {
+		// 완주자 명단에 없다면 완주하지 못한 참가자 이므로 바로 종료
+		if (!set.has(participant[i])) {
+			answer = participant[i];
+			break;
+		}
+		// 배열안에 특정값 갯수 확인
+		let count = participant.reduce(
+			(a, v) => (v === participant[i] ? a + 1 : a),
+			0
+		);
+		// 해당 값이 참가자 그룹 내 2명 이상이고 이전 최대 동명이인 참가자보다 많다면
+		// 해당 로직을 반복하면 제일 많은 동명이인을 알 수 있다
+		if (count > 1 && max < count) {
+			answer = participant[i];
+			// 조건에 맞는 동명이인 수 저장
+			max = count;
+		}
+	}
+	return answer;
+}

level-1/음양-더하기.js

@@ -13,5 +13,20 @@ function solution(absolutes, signs) {
     for (let i = 0; i < absolutes.length; i++) {
         answer += signs[i] ? absolutes[i] : -1 * absolutes[i]
     }
+    return answer;
+}
+
+//정답 3 - jaewon1676
+function solution(absolutes, signs) {
+    var answer = 0
+    for(var i=0; i<absolutes.length; i++){
+        if (signs[i] === false){
+            answer = answer - absolutes[i]
+        }
+        else{
+            answer = answer + absolutes[i]
+        }
+    }
+    
     return answer;
 }

level-1/크레인-인형뽑기-게임.js

@@ -22,4 +22,34 @@ function solution(board, moves) {
     })
 
     return answer;
-}
+}
+
+//정답 2 - jaewon1676 
+function solution(board, moves) {
+    var answer = 0; // 인형을 터뜨린 횟수
+    let basket = []; // 바구니
+    let crane = 0; // 크레인의 행의 위치
+    for (let i=0; i<moves.length; i++){
+        crane = moves[i] - 1; // crane = 0
+        for (let j=0; j<board.length; j++){
+            if (board[j][crane] == 0) continue;
+            else if (board[j][crane] != 0){
+                basket.push(board[j][crane])
+                board[j][crane] = 0
+                if (basket[basket.length-1] == basket[basket.length-2]){
+                    basket.pop();
+                    basket.pop();
+                    answer += 2;                
+                }
+                break;
+            }
+        }
+    }
+
+    return answer;
+}
+/* 풀이 과정
+1. 입력받은 moves의 length만큼 for문을 돌린다.
+2. 크레인에 찾고자 하는 행을 저장하여 제일 윗부분부터 탐색한다., 제일 윗부분이 비어있으면 다음 행으로 넘어가면서 탐색 한다.
+3. 값이 들어있으면 해당 값을 바구니에 push 해주고, 비워준다.
+4. 바구니 배열의 끝부분에 같은 인형 값이 연속되어있으면 연속 된 인형들을 pop 해주고, answer에 인형이 터진 횟수인 2를 더해준다. */

level-1/평균-구하기.js

@@ -4,4 +4,13 @@
 function solution(arr) {
     var answer = arr.reduce((prev, current) => prev + current) / arr.length
     return answer;
+}
+
+//정답 2 - jaewon1676
+function solution(arr) {
+    var answer = 0;
+    for (var i = 0; i < arr.length; i++) {
+        answer += arr[i]
+    }
+    return answer / arr.length;
 }