Keep Going

문제

현재 대기목록에 있는 문서의 중요도가 순서대로 담긴 배열 priorities와 내가 인쇄를 요청한 문서가 현재 대기목록의 어떤 위치에 있는지를 알려주는 location이 매개변수로 주어질 때, 내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 return 하도록 solution 함수를 작성해주세요.

1. 인쇄 대기목록의 가장 앞에 있는 문서(J)를 대기목록에서 꺼냅니다.
2. 나머지 인쇄 대기목록에서 J보다 중요도가 높은 문서가 한 개라도 존재하면 J를 대기목록의 가장 마지막에 넣습니다.
3. 그렇지 않으면 J를 인쇄합니다.

제한사항

• 현재 대기목록에는 1개 이상 100개 이하의 문서가 있습니다.
• 인쇄 작업의 중요도는 1~9로 표현하며 숫자가 클수록 중요하다는 뜻입니다.
• location은 0 이상 (현재 대기목록에 있는 작업 수 - 1) 이하의 값을 가지며 대기목록의 가장 앞에 있으면 0, 두 번째에 있으면 1로 표현합니다.

필요 개념

배열에 값 추가 

unshift() : 배열의 맨 앞에 값 추가

push() : 배열의 맨 끝에 값 추가

배열에 값 제거

shift() : 배열의 맨 앞에 값 제거

pop() : 배열의 맨 뒤의 값 제거

풀이

출력횟수를 카운트할 변수 count

현재 위치 인덱스를 담고 변경해줄 변수 myDoc

while문으로 반복해서 배열을 돌면서 

현재 위치의 요소를 꺼낸 후(shift),

나머지 요소들과 비교해서 제일 높은 숫자라면 출력한다(카운팅). 만약 내 인덱스 변수가 0번째라면 answer에 담아서 리턴한다. 

나머지 요소들과 비교해서 현재 위치 요소보다 높은 숫자가 있다면, 꺼낸 요소를 배열의 맨 뒤에 다시 넣는다(push)

(이후 공통으로)

내 인덱스를 유지하기 위해 배열 내 이동이 있었으므로 -1씩해준다. 

만약 내 문서가 맨 뒤로 간 경우, 내 문서의 위치도 맨 뒤로 바꿔준다. 

코드

const solution = (priorities, location) => {
    let answer;
    let count= 0;
    let myDoc = location;
    
    while(priorities.length>0){
        let item = priorities.shift();
        if(priorities.filter((el) => el > item).length>0){
            priorities.push(item);
        } else {
            count++;
            if(myDoc === 0) {
                return answer = count;
            }
        }
        myDoc--;
        if(myDoc === -1){
            myDoc = priorities.length -1;
        }
    }
    
    return answer;
}

다른 풀이 코드

function solution(priorities, location) {
    let temp = [...priorities];
    let max = 0;
    let answer = 0;
    while(temp.length>0) {
        max = Math.max(...temp);
        if(temp[0] !== max) {
            temp.push(temp.shift());
        } else {
            temp.shift();
            answer++;
            if(location===0) return answer;
        }
        location>0 ? location-- : location = temp.length - 1;
    }
}

문제

Finn은 요즘 수학공부에 빠져 있습니다. 수학 공부를 하던 Finn은 "자연수 n을 연속한 자연수들로 표현 하는 방법"이 여러개라는 사실을 알게 되었습니다.

예를들어 15는 다음과 같이 4가지로 표현 할 수 있습니다.

1 + 2 + 3 + 4 + 5 = 15

4 + 5 + 6 = 15

7 + 8 = 15

15 = 15

자연수 n이 매개변수로 주어질 때, 연속된 자연수들로 n을 표현하는 방법의 수를 return하는 solution를 완성해주세요.

풀이

처음에 찾은 규칙은 약수를 이용하면 될 것 같았다.

15의 약수의 개수 [1,3,5,15] -> 4개

14의 약수로 계산해보았을 때 

연속된 경우로 찾을 수 있는 것은 2가지인데,

2+3+4+5 = 14

14 = 14 

약수는 [1,2,7,14] 4개이다. 

완전탐색으로 풀어야하나 싶어서 Array.from으로 1부터 n까지 담긴 배열을 만들고, 누적해서 더하다가 15가 되면 카운팅을 한다. 되긴할 것 같은데 시간복잡도에서 별로인 방법이라고 생각했고, 약수를 이용하는 방법을 찾아보기로 했다.

해당 문제는

"주어진 수를 연속된 자연수의 합으로 표현하는 방법의 수"와

"주어진 수의 홀수인 약수의 갯수"는 같다.

주어진 수 를 연속된 자연수의 합으로 표현하는 방법 수 = 주어진 수의 약수 중에 홀수의 개수

는 공식을 이용한 풀이라고한다. 

약수 중에 홀수인 것의 갯수를 찾아야했다. 

*약수 : 어떤 수를 나누어 나머지 없이 떨어지는 수

15의 약수는 1, 3, 5, 15 이고 이 중 홀수는 4개이다. 

• 약수 1 => 연속하는 1개 자연수의 합으로 표현 가능
   15 = 15
• 약수 3 => 연속하는 3개 자연수의 합으로 표현 가능15를 3으로 나눈값인 5로 표현할 수 있다.
   5 + 5 + 5 = 15 => 3 + 4 + 5 = 15
• 약수 5 => 연속하는 5개 자연수의 합으로 표현 가능15를 5로 나눈값인 3으로 표현할 수 있다.
   3 + 3 + 3 + 3 + 3 = 15 => 1 + 2 + 3 + 4 + 5 = 15
• 약수 15 => 모든 홀수(2n+1)는 n과 n+1로 표현 가능
   7 + 8 = 15

코드

const solution = (n) => {
  let count = 0;

  for (let i = 0; i <= n; i++) {
    if (n % i === 0 && i % 2 !== 0) {
      count++;
    }
  }

  return count;
}

문제

길이가 같은 배열 A, B

배열 A, B에서 각각 한 개 숫자 뽑아 두 수를 곱한다. -> 배열의 길이만큼 반복. 

두 수를 곱한 값을 누적하여 더한다.

최종적으로 누적된 값이 최소가 되도록

(각 배열에서 k번째 숫자 뽑았다면 다음번에 k번째 숫자는 뽑을 수 없다)

배열 A, B가 주어질 때 최종저긍로 누적된 최솟값을 return 하는 solution 함수를 완성해주세요.

제한사항

- 배열 A, B의 크기 : 1,000 이하의 자연수

- 배열 A, B의 원소의 크기 : 1,000 이하의 자연수

풀이

A에서 가장 작은 값과 B에서 가장 큰 값을 곱하면서 누적하면 최솟값이 만들어진다. 

A를 오름차순 정렬하고, B를 내림차순 정렬한다. 그리고 같은 인덱스 값끼리 곱하면서 누적한 결과값을 리턴한다. 

처음에는 어렵게 생각해서 완전탐색으로 풀어야하나 고민했다. 

테스트 케이스로 주어진 2개의 입출력을 보면서 규칙을 보면

배열에서 가장 큰 값부터 순서대로와 가장 작은 값부터 순서대로 곱해서 최솟값을 만들고있었다. (역시 테스트 케이스를 잘 보면서 규칙을 찾아야했다.)

코드

const solution = (A, B) => {
  let answer = 0;

  A.sort((a, b) => a - b);
  B.sort((a, b) => b - a);

  for (let i = 0; i < A.length; i++) {
    answer += A[i] * B[i];
  }

  return answer;
}

문제

주어진 조건에 맞는 n의 다음 큰 숫자를 return 하는 solution 함수를 완성해주세요.

- 조건 1. n의 다음 큰 숫자는 n보다 큰 자연수 입니다.

- 조건 2. n의 다음 큰 숫자와 n은 2진수로 변환했을 때 1의 갯수가 같습니다.

- 조건 3. n의 다음 큰 숫자는 조건 1, 2를 만족하는 수 중 가장 작은 수 입니다.

입출력 예

풀이

n보다 크고, 2진수로 변환했을때 n과 1의 갯수가 같다 -> n과 n보다 큰수를 2진수로 변환한다.

조건 2가지를 만족하는 수 중에서 가장 작은 수

2진수로 변환 -> toString() 함수를 사용한다. 

n의 1의 개수를 찾아놓고,

while문으로 n을 하나씩 증가시키면서 다음 큰 수의 2진수의 1의 개수를 찾는다.

비교해서 같으면 멈추고, n을 리턴한다.

코드

const solution = (n) => {
  let binary = n.toString(2);
  let count = 0;

  // count : n의 이진수에서 1의 개수
  for (let x of binary) {
    if (x === '1') count++;
  }

  while (true) {
    n += 1;
    let bigNumBinary = n.toString(2);
    let bigNumCount = 0;

    // 다음 큰 숫자의 count
    for (let x of bigNumBinary) {
      if (x === '1') bigNumCount++;
    }

    if (count === bigNumCount) break;
  }
  return n;
}

문제

문자열 s는 한 개 이상의 단어로 구성되어 있습니다. 각 단어는 하나 이상의 공백문자로 구분되어 있습니다. 각 단어의 짝수번째 알파벳은 대문자로, 홀수번째 알파벳은 소문자로 바꾼 문자열을 리턴하는 함수, solution을 완성하세요.

제한 사항

• 문자열 전체의 짝/홀수 인덱스가 아니라, 단어(공백을 기준)별로 짝/홀수 인덱스를 판단해야합니다.
• 첫 번째 글자는 0번째 인덱스로 보아 짝수번째 알파벳으로 처리해야 합니다.

풀이

문자열의 짝수 인덱스는 대문자로 바꿔주고, 홀수 인덱스는 소문자로 바꿔주는 간단한 문제였다. 

꼼꼼하게 짝수 홀수 처리를 해줘야했다. 예시에 있는 테스트 케이스는 통과인데

제출해보면 테스트케이스가 16개중에 4개밖에 통과가 되지않았다.

문제를 꼼꼼하게 읽어야했다. 

try 

hello

world

공백을 기준으로 나눠서 다시 인덱스를 찾아줘야했다. 

처음 작성한 코드

const solution = (s) => {
  let answer = '';
  let string = s.split('');

  for (let i = 0; i < string.length; i++) {

      if (i % 2 === 0) {
        answer += string[i].toUpperCase();
      } else {
        answer += string[i].toLowerCase();
      }
  }
  return answer;
}

const s = "try hello world";
console.log(solution(s))

최종 코드

const solution = (s) => {
  let answer = '';
  let index = 0;

  for (let i = 0; i < s.length; i++) {
    if (s[i] === ' ') {
      index = 0; // 공백이면 인덱스 다시 0으로 초기화
      answer += ' ';
    } else {
      if (index % 2 === 0) {
        answer += s[i].toUpperCase();
      } else {
        answer += s[i].toLowerCase();
      }
      index++; // 공백이 아닐때 인덱스 증가
    }
  }
  return answer;
}

const s = "try hello world";
console.log(solution(s));

통과가 안되면 문제를 다시 읽어보자. 

그 전에 문제를 꼼꼼하게 읽자.

문제

로또 번호를 담은 배열 lottos, 당첨 번호를 담은 배열 win_nums가 매개변수로 주어집니다. 이때, 당첨 가능한 최고 순위와 최저 순위를 차례대로 배열에 담아서 return 하도록 solution 함수를 완성해주세요.

코드

const solution = (lottos, win_nums) => {
  let answer = [];

  let zeroCount = lottos.filter((el) => el === 0).length;
  let sameNums = lottos.filter((el) => win_nums.includes(el)).length;

  let min = 7 - sameNums >= 6 ? 6 : 7 - sameNums; // 최저순위
  let max = min - zeroCount < 1 ? 1 : min - zeroCount// 최고순위

  answer = [max, min];
  return answer;
}

const lottos = [44, 1, 0, 0, 31, 25];
const win_nums = [31, 10, 45, 1, 6, 19];
console.log(solution(lottos, win_nums));

문제

원하는 상품을 골라 가격과 배송비를 제출하라

현재 예산으로 최대 몇 명의 학생에서 선물을 사줄 수 있는지

상품 하나를 50% 할인해서 살 수 있는 쿠폰 있다. 배송비는 할인에 포함되지 않는다.

입력예제 |

예산 28

제출한 가격과 배송비 [6, 6], [2, 2], [4, 3], [4, 5], [10, 3]

출력예제 |

4

풀이

총 비용을 기준으로 정렬을 한다.

쿠폰을 어떤 가격에 적용시켜야하는가 -> 기준이 없기 때문에 모든 경우를 다 찾아봐야한다. 

첫 번째 상품을 할인받는다 생각하고, 총 비용에서 제외하고 계산

두 번째 상품을 할인받는다 생각하고 총 비용에서 제외하고 계산

.

.

.

다 해보는 것이 완전탐색

a[0]+a[1]  상품가격+배송비

전체 비용해서 첫 번째 금액을 할인해서 뺀다. → 카운팅은 1부터 시작

코드

const solution = (budget, product) => {
  let answer = 0;
  let n = product.length;

  product.sort((a, b) => (a[0] + a[1]) - (b[0] + b[1])); // 총합 순서대로 오름차순 정렬 먼저해주기

  // for문 돌면서 모든 상품이 한 번씩 할인받는 경우 해보기
  for (let i = 0; i < n; i++) {
    // 전체 예산 구하기
    let money = budget - (product[i][0] / 2 + product[i][1]); // 할인받은 금액을 전체 예산에서 뺀다.(산 경우로 계산)
    let count = 1; // 위의 계산으로 1개는 계산했다는 가정으로 1부터 시작함
    for (let j = 0; j < n; j++) {
      // i는 이미 할인된 상품이므로 j가 i랑 같은 경우는 안되도록 처리
      if (j !== i && (product[j][0] + product[j][1]) > money) break; // 사려고하는 것이 남은 예산보다 큰 경우 break;
      if (j !== i && (product[j][0] + product[j][1]) <= money) { // 남은예산보다 작거나 같아야한다.
        money -= (product[j][0] + product[j][1]); // 전체에서 비용 빼주기
        count++; // 상품 개수 카운팅
      }
    }
    answer = Math.max(answer, count);
  }
  return answer;
}

const budget = 28;
const product = [[6, 6], [2, 2], [4, 3], [4, 5], [10, 3]];
console.log(solution(budget, product));

주석 없는 전체코드

const solution = (budget, product) => {
  let answer = 0;
  let n = product.length;

  product.sort((a, b) => (a[0] + a[1]) - (b[0] + b[1]));

  for (let i = 0; i < n; i++) {
    let money = budget - (product[i][0] / 2 + product[i][1]); 
    let count = 1;
    for (let j = 0; j < n; j++) {
      if (j !== i && (product[j][0] + product[j][1]) > money) break;
      if (j !== i && (product[j][0] + product[j][1]) <= money) {
        money -= (product[j][0] + product[j][1]);
        count++;
      }
    }
    answer = Math.max(answer, count);
  }
  return answer;
}

const budget = 28;
const product = [[6, 6], [2, 2], [4, 3], [4, 5], [10, 3]];
console.log(solution(budget, product));

문제

가장 긴 가로 길이와 세로 길이가 각각 80, 70이기 때문에 80(가로) x 70(세로) 크기의 지갑을 만들면 모든 명함들을 수납할 수 있습니다. 하지만 2번 명함을 가로로 눕혀 수납한다면 80(가로) x 50(세로) 크기의 지갑으로 모든 명함들을 수납할 수 있습니다. 이때의 지갑 크기는 4000(=80 x 50)입니다.

모든 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어집니다. 모든 명함을 수납할 수 있는 가장 작은 지갑을 만들 때, 지갑의 크기를 return 하도록 solution 함수를 완성해주세요.

풀이

가로 길이 중에 가장 긴 것, 세로 길이 중에 가장 긴 것을 곱한게 최소 지갑크기가 될 수 있다.

하지만 세로길이가 가장 큰 명함이 가로로 눕혀서 수납할 수 있게된다면, 더 작은 사이즈로 만들 수 있다. 

각 배열에서 원소끼리 비교해서 큰 값은 0번째, 작은 값은 1번째 자리에 배치한다. 그리고 큰 값을 모아서 big이라는 배열에 push하고, 작은 값을 small이라는 배열에 push한다. 같을 경우 그대로 넣는다. 각 배열에서 Math.max() 메소드로 찾아서 곱하고 answer로 리턴한다. 

코드

const solution = (sizes) => {
  let answer;
  let temp;
  let small = [];
  let big = [];

  for (let i = 0; i < sizes.length; i++) {
    if (sizes[i][0] < sizes[i][1]) {
      temp = sizes[i][1];
      sizes[i][1] = sizes[i][0];
      sizes[i][0] = temp;
    }
    small.push(sizes[i][1]);
    big.push(sizes[i][0]);
  }
  
  answer = Math.max(...big) * Math.max(...small);
  return answer;
}

const sizes = [[60, 50], [30, 70], [60, 30], [80, 40]];
console.log(solution(sizes));

다른 풀이

매핑을 해서 정렬된 배열을 만들고, 바로 0번째 요소들만 매핑해서 최대값을 찾고, 1번째 요소들만 매핑해서 최대값을 찾아서 곱해서 리턴하는 방법도 있었다. 

const solution = (sizes) => {
  const newSizes = sizes.map(e => e.sort((a, b) => a - b));
  return Math.max(...newSizes.map(e => e[0])) * Math.max(...newSizes.map(e => e[1]));
}

const sizes = [[60, 50], [30, 70], [60, 30], [80, 40]];
console.log(solution(sizes));