H-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 h를 구하려고 합니다. 위키백과1에 따르면, H-Index는 다음과 같이 구합니다.

• 어떤 과학자가 발표한 논문 n편 중, h번 이상 인용된 논문이 h편 이상이고 나머지 논문이 h번 이하 인용되었다면 h의 최댓값이 이 과학자의 H-Index입니다.

어떤 과학자가 발표한 논문의 인용 횟수를 담은 배열 citations가 매개변수로 주어질 때, 이 과학자의 H-Index를 return 하도록 solution 함수를 작성해주세요.

제한 사항

• 과학자가 발표한 논문의 수는 1편 이상 1,000편 이하입니다.
• 논문별 인용 횟수는 0회 이상 10,000회 이하입니다.

입출력 예

입출력 예 설명

이 과학자가 발표한 논문의 수는 5편이고, 그중 3편의 논문은 3회 이상 인용되었습니다. 그리고 나머지 2편의 논문은 3회 이하 인용되었기 때문에 이 과학자의 H-Index는 3입니다.

내가 푼 답

function solution(citations) {
    citations.sort((a, b) => b - a);  // 내림차순으로 정렬

    for(let i = 0; i < citations.length; i++) {
        if(citations[i] <= i) {
            return i;  // H-Index 반환
        }
    }

    return citations.length;  // 모든 논문의 인용 횟수가 논문의 수보다 큰 경우
}

Code Flow

• 생각하기

  • 간단하게 생각하면, n편중에 h번 인용된 논문이 h번이고, 나머지가 h번 이하면, => 그냥 중앙값 찾으란 소리야.
  • [3, 0, 6, 1, 5]인데, 3편의 논문이 3회 이상 인용되었고, 나머지는 3회 미만이기때문에 H-index는 3이다.
  • 배열의 중앙값을 찾고, 중앙값에서 멈추면 그게 h-index아님? => 아닌가?

라고 생각했었다. 근데 아니었다. 문제의 가독성에 이상이 있는게 틀림없다!!!

• 다시금 생각하기

  • 예를 들어보자, 테스트 값말고, [9, 9, 9, 9, 1] 이렇게 있으면, h-index값은 4야.
  • 즉 h-index와 중앙값은 항상 일치하지 않는다.
  • 그럼 이럴경우 h-index를 어떻게 구할까? 라고 생각하면 내림차순 하고서,
  • 논문의 횟수가 인용의 횟수보다 작은 경우를 생각하면 되겠지?
  • 다만 논문의 인용횟수가 논문의 수보다 다 큰경우에는, 그냥 length를 반환하면 된다.

배열의 순회는 이런 느낌

i = 0, citations[0] = 9, i+1 = 1: 9 > 1
i = 1, citations[1] = 9, i+1 = 2: 9 > 2
i = 2, citations[2] = 9, i+1 = 3: 9 > 3
i = 3, citations[3] = 9, i+1 = 4: 9 > 4
i = 4, citations[4] = 1, i+1 = 5: 1 < 5

• 따라서, 임시예제의 기준으로 h-index는 4이다.

다른 해답은 없을까?

function solution(citations) {

    // citations 배열을 내림차순으로 정렬하기 위해 sorting 함수를 사용합니다.
    citations = citations.sort(sorting);

    // i는 현재 확인하고 있는 논문의 순위(0부터 시작)를 나타냅니다.
    var i = 0;

    // i + 1 (실제 논문의 개수)이 해당 논문의 인용 횟수보다 작거나 같은 동안 반복합니다.
    // 이 조건이 만족되면 H-Index가 i보다 크다는 의미입니다.
    while(i + 1 <= citations[i]){
        i++;
    }

    // 위의 반복문을 빠져나왔을 때 i 값이 H-Index에 해당합니다.
    return i;

    // 내림차순 정렬을 위한 helper 함수입니다.
    function sorting(a, b){
        return b - a;
    }
}

이 문제를 풀면서 공부한 것

• helper함수를 사용하였다. 특히 sort() 메소드는 인자값으로 comparator 함수를 받을 수 있다는 점이 인상적이었다.
  • 특히 sort() 함수를 이렇게 써야하는구나. 라고 생각을 많이 하게 되었음.
    • 단순히 오름차순, 내림차순만 쓰던 나.. 반성해..

0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.

• 예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.

0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.

제한 사항

• numbers의 길이는 1 이상 100,000 이하입니다.
• numbers의 원소는 0 이상 1,000 이하입니다.
• 정답이 너무 클 수 있으니 문자열로 바꾸어 return 합니다.

입출력 예

내가 푼 답

function solution(numbers) {
    // 숫자들을 문자열로 변환
    let strNumbers = numbers.map(num => num.toString());

    // 문자열로 변환한 숫자들을 서로 연결하여 비교하는 방식으로 정렬
    strNumbers.sort((a, b) => (b + a) - (a + b) > 0 ? 1 : -1);

    // 정렬된 문자열들을 연결하여 결과를 생성
    let answer = strNumbers.join('');

    // 예외사항) 만약 모든 숫자가 0이라면 "0"을 반환
    return answer[0] === '0' ? '0' : answer;
}

Code Flow

생각하기

• 정수가 주어진것들이 string 처리 되었을때, 가장 큰 수를 찾는 방식.
• 생각해보니까 이거, 문자열로 치환하고 sort(b-a)쓰면 역사전순 치환되니까, 가장 큰 사전순으로 나오지 않을까?
• 먼저 number에 들어있는 아이들을 ,을 기준으로 잘라내주고, 그다음 모두 string으로 바꾼 후에
• 역사전순으로 sort 정렬해주고, 그걸 join 해서 answer에 넣으면 해결되는게 아닐까?

풀이하기

1. 숫자열을 먼저 문자열로 변환해준다, map을 이용해서.
2. 그 다음 문자열로 변환된 숫자들을 내림차순으로 했더니, 문제가 발생. 전 문제 기준으로 생각해서, 문자열을 서로 연결해서 비교하는 방식으로 수정하였다.
3. 그 다음 정렬된 문자들을 join()을 이용해서 하나로 붙여주면 완성.
4. 문제는 여기서 발생, undefined가 뜨길래 왜 일까 하고 고민하다가 찾아보니, 0이 들어갔을때 오류가 나는걸로 나옴. 그래서 0이 들어가있다면, 그냥 0을 반환하는걸로 했음.

다른 해답은 없을까?

function solution(numbers) {
    var answer = numbers.map(v=>v+'')
                        .sort((a,b) => (b+a)*1 - (a+b)*1)
                        .join('');

    return answer[0]==='0'?'0':answer;
}

배울점

1. `map` 함수에서 `(v => v+'')`를 아직 이해 못한듯. 이게 `toString`이랑 똑같다는데. 흠.

2. `sort()`에서 *1을 해주면 다시 숫자열로 변환한다고 함. 이것도 몰랐다.

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다. 예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면

1. array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다.
2. 1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다.
3. 2에서 나온 배열의 3번째 숫자는 5입니다.

배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한 사항

• array의 길이는 1 이상 100 이하입니다.
• array의 각 원소는 1 이상 100 이하입니다.
• commands의 길이는 1 이상 50 이하입니다.
• commands의 각 원소는 길이가 3입니다

입출력 예

입출력 예 설명

1. [1, 5, 2, 6, 3, 7, 4]를 2번째부터 5번째까지 자른 후 정렬합니다. [2, 3, 5, 6]의 세 번째 숫자는 5입니다.
2. [1, 5, 2, 6, 3, 7, 4]를 4번째부터 4번째까지 자른 후 정렬합니다. [6]의 첫 번째 숫자는 6입니다.
3. [1, 5, 2, 6, 3, 7, 4]를 1번째부터 7번째까지 자릅니다. [1, 2, 3, 4, 5, 6, 7]의 세 번째 숫자는 3입니다.

내가 푼 답

function solution(array, commands) {
    let answer = [];

    for(let command of commands) {
        // array를 command[0]-1부터 command[1] 인덱스까지 잘라서 새 배열을 생성
        let newArray = array.slice(command[0]-1, command[1]);
        // 새 배열을 정렬
        newArray.sort((a, b) => a - b);
        // 정렬된 배열에서 command[2]-1 인덱스의 값을 answer 배열에 추가
        answer.push(newArray[command[2]-1]);
    }

    return answer;
}

Code Flow

• 가장 중요하다고 생각한 것 : commands 에는 각 원소가 적혀져있고, index[0]부터 index[1]까지, index[2]번에 answer[]에 푸쉬한다.

• commands는 2차원 배열이니까, 2차원 배열을 1차원으로 하나씩 빼내야함.
  • for of 문을 사용하여 하나씩 빼내자.

• NewArraycommands[0] 배열의 index[0]부터 index[1]까지, index[2]번에 있는 걸 answer에 푸쉬.

• 새 배열을 만들고, slice 함수를 이용해서 잘라내준다.
  • 여기서 중요한점은, slice 함수가 start는 포함하고, endpoint는 포함하지 않는다는 점이다. 그 예시로, command[0]하면 index[1]부터 시작하게 된다. 꼭 -1 해줄 것!

• 그리고서 새 배열을 오름차순으로 정렬해준다.

• 그리고 정렬된 배열에서 command[2]-1 해주고 그 값을 answer에 푸쉬하면 끝.
  • 여기서도 중요한점이, command[2]-1 해주는 이유가, 자바스크립트에서는 0-base 함수라서 그렇다고 한다. index값이 0부터 시작하니까.

다른 해답은 없을까?

function solution(array, commands) {
    return commands.map(v => {
        return array.slice(v[0] - 1, v[1]).sort((a, b) => a - b).slice(v[2] - 1, v[2])[0];
    });
}

• map 메소드를 사용하여 commands의 각 원소 (크기 3의 배열)에 대해 다음 동작을 수행합니다:

1. array에서 v[0] - 1부터 v[1]까지의 구간을 slice로 추출합니다.
2. 추출한 배열을 오름차순으로 정렬합니다.
3. 정렬된 배열에서 v[2] - 1 위치의 원소를 추출합니다.
4. map 메소드는 이러한 동작을 각 commands 원소에 대해 수행하며, 그 결과로 얻은 배열을 반환합니다.

이 문제를 풀면서 공부한 것.

1. slice() 함수는 start는 포함하고 end는 포함하지 않는다.

   • i번째부터 j번째 원소를 가져오기 위해서는 slice(i-1, j)와 같이 사용해야 한다.

2. sort() 함수의 sort(a, b) => ( a - b ) or ( b - a ) 는 그냥 오름차순, 내림차순을 해주려고 하는게 아닌 사전순 정렬을 막기 위해서다.

3. 대부분의 프로그래밍 함수들은 0-based indexing이다.

등차수열 혹은 등비수열 common이 매개변수로 주어질 때, 마지막 원소 다음으로 올 숫자를 return 하도록 solution 함수를 완성해보세요.

제한 사항

• 2 < common의 길이 < 1,000
• 1,000 < common의 원소 < 2,000
• common의 원소는 모두 정수입니다.
• 등차수열 혹은 등비수열이 아닌 경우는 없습니다.
• 등비수열인 경우 공비는 0이 아닌 정수입니다.

입출력 예

내가 푼 답

function solution(common) {
  // 등차수열 판단
  if (common[1] - common[0] === common[2] - common[1]) {
    // 등차수열인 경우 다음 숫자는 마지막 숫자 + 등차값
    return common[common.length - 1] + (common[1] - common[0]);
  } else {
    // 등비수열인 경우 다음 숫자는 마지막 숫자 * (공비값)
    return common[common.length - 1] * (common[1] / common[0]);
  }
}

Code Flow

생각하기

• 등비수열이거나 등차수열인 경우라면, 해당 값이 얼마나 더해지고 곱해지느냐를 구하는게 관건이다
  1. 일단 index[1] - index[0] 했을때 나오는 값을 구해보고
  2. 그리고 index[2] - index[1] 했을때 나오는 값이 동일하면 등차수열, 동일하지 않다면 등비수열이다.
  3. 등차수열의 경우 마지막 index값에서 등차값을 더해주면 되고
  4. 등비수열의 경우 마지막 index값에서 등비값을 곱해주면 된다.

다른 해답은 없을까?

function solution(common) {
    if ((common[1]-common[0])==(common[2]-common[1])){
        return common.pop() + common[1] - common[0];
    }
    else{
        return common.pop()*common[1]/common[0];
    }
}

• POP()을 쓴다는게 신기해서 가져와 봤다.

연속된 세 개의 정수를 더해 12가 되는 경우는 3, 4, 5입니다. 두 정수 num과 total이 주어집니다. 연속된 수 num개를 더한 값이 total이 될 때, 정수 배열을 오름차순으로 담아 return하도록 solution함수를 완성해보세요.

제한 사항

• 1 ≤ num ≤ 100
• 0 ≤ total ≤ 1000
• num개의 연속된 수를 더하여 total이 될 수 없는 테스트 케이스는 없습니다.

입출력 예

내가 푼 답

function solution(num, total) {
  const result = [];

  // 중앙 숫자가 정수인 경우
  if (total % num === 0) {
    // 중앙 숫자 계산
    const middle = Math.floor(total / num);

    // 중앙을 기준으로 좌우로 num/2 개의 숫자를 더해줌
    for (let i = 0; i < num; i++) {
      result.push(middle - Math.floor(num / 2) + i);
    }
  } else { // 중앙 숫자가 소수인 경우
    const leftMiddle = Math.floor(total / num);
    const rightMiddle = Math.ceil(total / num);

    // 왼쪽 숫자부터 추가
    for (let i = 0; i < num / 2; i++) {
      result.unshift(leftMiddle - i);
    }

    // 오른쪽 숫자 추가
    for (let i = 0; i < num / 2; i++) {
      result.push(rightMiddle + i);
    }
  }

  return result;
}

Code Flow

생각하기

• 연속된 수 num 만큼 더해서 total을 완성하는 작업.
• 생각해봤는데, total에서 num을 나눴을때 나오는 숫자가 중앙 숫자고, num을 기준으로 index[중앙숫자-i] + index[중앙숫자+i] 만큼 해주면 되는게 아닐까?
• 그리고 소숫점으로 나오면, 중앙숫자가 그 중앙의 2개인거임. ex) 3.5로 나오면 중앙숫자가 3/4를 중앙값로 삼고, 다시 index[중앙숫자-i] 와 index[중앙숫자+i] 하면 되는거지.
• 다만 왼쪽 오른쪽으로 다시금 나뉘었으니 i < num/2 해야함.

다른 해답은 없을까?

function solution(num, total) {
    var min = Math.ceil(total/num - Math.floor(num/2));
    var max = Math.floor(total/num + Math.floor(num/2));

    return new Array(max-min+1).fill(0).map((el,i)=>{return i+min;});
}

예제 4번을 기준으로 보자.

1. min 계산

• 3.5 - 2 = 1.5 => ceil으로 min은 2가 된다.

2. max 계산

• 3.5 + 2 = 5.5 => floor로 max는 5가 된다.

3. Array를 통해 배열을 만들어주고, 그것을 fill을 통해 채워준다, 그 후 map을 통해 i + min 값을 출력한다.

기억할 함수

.Map(el, idx, arr) : 원본 데이터를 변형하지 않고, 새로운 함수를 만들어 낸다.

- element: 현재 요소의 값
- index: 현재 요소의 인덱스
- array: 원본 배열 자체

머쓱이는 큰 종이를 1 x 1 크기로 자르려고 합니다. 예를 들어 2 x 2 크기의 종이를 1 x 1 크기로 자르려면 최소 가위질 세 번이 필요합니다.

정수 M, N이 매개변수로 주어질 때, M x N 크기의 종이를 최소로 가위질 해야하는 횟수를 return 하도록 solution 함수를 완성해보세요

제한 사항

• 0 < M, N < 100
• 종이를 겹쳐서 자를 수 없습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 본문과 동일합니다.

입출력 예 #2

• 가로 2 세로 5인 종이는 가로로 1번 세로로 8번 총 가위질 9번이 필요합니다.

입출력 예 #3

• 이미 1 * 1 크기이므로 0을 return 합니다.

내가 푼 답

function solution(M, N) {
    let CutM = M - 1;
    let CutN = M * (N - 1)

    return CutM + CutN;
}

Code Flow

생각하기

1. 간단하게 생각하면, M은 한번에 자른다고 생각했을때 m -1 만큼 자른다고 생각하면되고
2. 그 다음 N의 경우 m * n-1 만큼 자른다고 보면 된다.
3. 그렇게 잘랐을때, M 자른 횟수 + N 자른 횟수를 더하면 완성되는 작업이다.

다른 해답은 없을까?

function solution(M, N) {
    return M*N-1;
}

• 좀 더 간결히 푼 것 같다. 한 줄로.

문자열 "hello"에서 각 문자를 오른쪽으로 한 칸씩 밀고 마지막 문자는 맨 앞으로 이동시키면 "ohell"이 됩니다. 이것을 문자열을 민다고 정의한다면 문자열 A와 B가 매개변수로 주어질 때, A를 밀어서 B가 될 수 있다면 밀어야 하는 최소 횟수를 return하고 밀어서 B가 될 수 없으면 -1을 return 하도록 solution 함수를 완성해보세요.

제한 사항

0 < A의 길이 = B의 길이 < 100 A, B는 알파벳 소문자로 이루어져 있습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• "hello"를 오른쪽으로 한 칸 밀면 "ohell"가 됩니다.

입출력 예 #2

• "apple"은 몇 번을 밀어도 "elppa"가 될 수 없습니다.

입출력 예 #3

• "atat"는 오른쪽으로 한 칸, 세 칸을 밀면 "tata"가 되므로 최소 횟수인 1을 반환합니다.

입출력 예 #4

• "abc"는 밀지 않아도 "abc"이므로 0을 반환합니다.

내가 푼 답

function solution(A, B) {
  // 1. 두 문자열이 동일한 경우 0 반환
  if (A === B) {
    return 0;
  }

  // 2. 문자열을 분해하고 정렬하여 동일한 문자로 구성되어 있는지 확인
  const sortedA = A.split('').sort().join('');
  const sortedB = B.split('').sort().join('');

  if (sortedA !== sortedB) {
    return -1;
  }

  // 3. 오른쪽으로 밀 때의 횟수 계산
  let rightShiftCount = 0;
  let tempA = A;
  while (tempA !== B) {
    tempA = tempA[tempA.length - 1] + tempA.slice(0, tempA.length - 1);
    rightShiftCount++;

    // 횟수가 문자열 길이보다 크면 무한 루프 방지
    if (rightShiftCount > A.length) {
      return -1;
    }
  }

  // 4. 오른쪽으로 밀 때의 최소 횟수를 반환
  return rightShiftCount;
}

Code Flow

생각하기

1. 제일 먼저 두개를 동일한가? 확인하고 동일하면 0 return
2. 그리고서 하나하나 분해하고 sort했을때 A === B가 아니라면 -1을 return. 3-1. 그 다음으로 왼쪽으로 밀어보고 얼마나 밀리는지 확인 <= 이건 필요 없었다. 3-2. 오른쪽으로 밀어보고 얼마나 밀리는지 확인
3. 밀어본 두개의 값 중 낮은 값을 return 하게 한다. => 그게 아니라 오른쪽으로 밀었을때 몇번 밀면 되냐? 이거였다.

다른 해답은 없을까?

let solution=(a,b)=>(b+b).indexOf(a)

• B+B 안에 A가 존재한다면, indexOf(a)를 통해 어디서부터 시작하는지 알 수 있다.

  ex) b+b가 ohellohell 일때 indexOf(1) 이므로, 1을 반환한다.

다만 해당 풀이는 시간복잡도가 O(N^2) 일 수 있다.

• 왜냐하면, 두 문자열을 이어 붙이고 O(N)

• indexOf() 함수는 주어진 문자열을 순차적으로 검색하기 때문에 O(N)
• 이러한 과정을 두 번 반복하므로 O(N) * O(N) = O(N^2) 이 된다.

네트워크란 컴퓨터 상호 간에 정보를 교환할 수 있도록 연결된 형태를 의미합니다. 예를 들어, 컴퓨터 A와 컴퓨터 B가 직접적으로 연결되어있고, 컴퓨터 B와 컴퓨터 C가 직접적으로 연결되어 있을 때 컴퓨터 A와 컴퓨터 C도 간접적으로 연결되어 정보를 교환할 수 있습니다. 따라서 컴퓨터 A, B, C는 모두 같은 네트워크 상에 있다고 할 수 있습니다.

컴퓨터의 개수 n, 연결에 대한 정보가 담긴 2차원 배열 computers가 매개변수로 주어질 때, 네트워크의 개수를 return 하도록 solution 함수를 작성하시오.

제한 사항

• 컴퓨터의 개수 n은 1 이상 200 이하인 자연수입니다.
• 각 컴퓨터는 0부터 n-1인 정수로 표현합니다.
• i번 컴퓨터와 j번 컴퓨터가 연결되어 있으면 computers[i][j]를 1로 표현합니다.
• computer[i][i]는 항상 1입니다.

입출력 예

예제 2. 아래와 같이 1개의 네트워크가 있습니다.

내가 푼 답

function solution(n, computers) {
  let answer = 0;  // 네트워크 개수를 저장하는 변수 초기화
  let visit = [...computers];  // 컴퓨터 방문 여부를 나타내는 배열을 생성하고 computers 배열 복사

  for (let i = 0; i < n; i++) {  // 모든 컴퓨터에 대한 반복문 시작
    if (visit[i][i] !== -1) {  // 아직 방문하지 않은 컴퓨터인 경우
      answer++;  // 새로운 네트워크를 시작하고 answer 증가
      visit[i][i] = -1;  // 방문 표시 (-1로 표시하여 중복 방문을 막음)
    }

    for (let j = 0; j < n; j++) {  // 현재 컴퓨터와 연결된 모든 컴퓨터에 대한 반복문 시작
      if (visit[i][j] !== -1 && computers[i][j] === 1) {  // 아직 방문하지 않았고 연결되어 있는 경우
        visit[i][j] = -1;  // 방문 표시 (-1로 표시하여 중복 방문을 막음)
        visit[j][i] = -1;  // 양방향 연결을 고려하여 반대 방향도 방문 표시
        dfs(j, visit, computers);  // DFS 함수 호출하여 연결된 모든 컴퓨터 탐색
      }
    }
  }

  function dfs(i, visit, computers) {  // 깊이 우선 탐색 함수 정의
    for (let j = 0; j < n; j++) {  // 현재 컴퓨터와 연결된 모든 컴퓨터에 대한 반복문 시작
      if (visit[i][j] !== -1 && computers[i][j] === 1) {  // 아직 방문하지 않았고 연결되어 있는 경우
        visit[i][j] = -1;  // 방문 표시 (-1로 표시하여 중복 방문을 막음)
        visit[j][i] = -1;  // 양방향 연결을 고려하여 반대 방향도 방문 표시
        dfs(j, visit, computers);  // DFS 함수 호출하여 연결된 모든 컴퓨터 탐색
      }
    }
  }

  return answer;  // 최종적으로 찾은 네트워크 개수 반환
}

Code Flow

다른 해답은 없을까?

function solution(n, computers) {
    let visited = [false];
    let answer = 0;

    function dfs(i) {
        visited[i] = true;
        for(let j=0; j<computers[i].length; j++) {
            if(computers[i][j]===1 && !visited[j]){
                dfs(j);
            }
        }
    }

    for (let i=0; i < computers.length; i++) {
        if (!visited[i]) {
            dfs(i)
            answer++;
        }
    }
    return answer;
}

-1+1+1+1+1 = 3 +1-1+1+1+1 = 3 +1+1-1+1+1 = 3 +1+1+1-1+1 = 3 +1+1+1+1-1 = 3

사용할 수 있는 숫자가 담긴 배열 numbers, 타겟 넘버 target이 매개변수로 주어질 때 숫자를 적절히 더하고 빼서 타겟 넘버를 만드는 방법의 수를 return 하도록 solution 함수를 작성해주세요.

제한 사항

• 주어지는 숫자의 개수는 2개 이상 20개 이하입니다.
• 각 숫자는 1 이상 50 이하인 자연수입니다.
• 타겟 넘버는 1 이상 1000 이하인 자연수입니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 문제 예시와 같습니다.

입출력 예 #2

+4+1-2+1 = 4 +4-1+2-1 = 4

총 2가지 방법이 있으므로, 2를 return 합니다.

내가 푼 답

function solution(numbers, target) {
    var answer = 0;

    dfs(0, 0); //dfs를 이용해서 풀어주자

    function dfs(sum, index) { //sum과 index값은 0이다.
        if (index === numbers.length) { 
        //index가 배열 number의 길이와 같아지면 모든 수를 사용한 것이므로 마감하고, 
            if (sum === target) {
            //sum과 target이 같은지 확인하고, 일치하면 answer에 1을 더해준다
                answer += 1;
            } 
            return;
        }
      // 재귀 호출인 현재 숫자를 더하고 빼며 밑의 트리로 넘어간다. 
        dfs(sum + numbers[index], index + 1);
        dfs(sum - numbers[index], index + 1);
    }
    return answer;
}

Code Flow

1) dfs(0, 0);은 깊이 우선 탐색(Depth-First Search, DFS)을 시작합니다. dfs 함수를 최초로 호출하면서 초기 상태로서 현재 합 sum을 0으로, 현재 인덱스 index를 0으로 설정합니다.

2) function dfs(sum, index)는 주요 로직이 포함된 재귀 함수입니다.

• if (index === numbers.length)은 현재 인덱스 index가 배열 numbers의 길이와 같아지면, 모든 숫자를 사용한 것이므로 더 이상 숫자를 더하거나 빼는 작업을 진행하지 않고, 현재까지의 합 sum이 목표값 target과 일치하는지 확인합니다.
• if (sum === target)은 현재까지의 합 sum이 목표값 target과 일치하면, answer 변수를 1 증가시킵니다. return;은 함수를 종료하고 이전 호출로 돌아갑니다.

3) 재귀 호출부인 dfs(sum + numbers[index], index + 1);와 dfs(sum - numbers[index], index + 1);는 현재 숫자를 더하거나 빼며 다음 인덱스로 진행하는 작업입니다. 이렇게 재귀적으로 함수를 호출하면서 가능한 모든 조합을 검사합니다.

나는 잘 모르겠다. 자세히 해보자!

흑흑.. 어림도 없었다 ㅠㅠㅠ.. 하다 포기..

조이스틱으로 알파벳 이름을 완성하세요. 맨 처음엔 A로만 이루어져 있습니다. ex) 완성해야 하는 이름이 세 글자면 AAA, 네 글자면 AAAA

조이스틱을 각 방향으로 움직이면 아래와 같습니다.

▲ - 다음 알파벳 ▼ - 이전 알파벳 (A에서 아래쪽으로 이동하면 Z로) ◀ - 커서를 왼쪽으로 이동 (첫 번째 위치에서 왼쪽으로 이동하면 마지막 문자에 커서) ▶ - 커서를 오른쪽으로 이동 (마지막 위치에서 오른쪽으로 이동하면 첫 번째 문자에 커서)

예를 들어 아래의 방법으로 "JAZ"를 만들 수 있습니다.

• 첫 번째 위치에서 조이스틱을 위로 9번 조작하여 J를 완성합니다.
• 조이스틱을 왼쪽으로 1번 조작하여 커서를 마지막 문자 위치로 이동시킵니다.
• 마지막 위치에서 조이스틱을 아래로 1번 조작하여 Z를 완성합니다. 따라서 11번 이동시켜 "JAZ"를 만들 수 있고, 이때가 최소 이동입니다.

만들고자 하는 이름 name이 매개변수로 주어질 때, 이름에 대해 조이스틱 조작 횟수의 최솟값을 return 하도록 solution 함수를 만드세요.

제한 사항

• name은 알파벳 대문자로만 이루어져 있습니다.
• name의 길이는 1 이상 20 이하입니다.

입출력 예

내가 푼 답

function solution(name) {
  const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  let answer = 0;


  for (let i = 0; i < name.length; i++) {
    const diffUp = alphabet.indexOf(name[i]);
    const diffDown = alphabet.length - diffUp;
    answer += Math.min(diffUp, diffDown);
  }


  let minMove = name.length - 1;

  for (let i = 1; i < name.length; i++) {
    if (name[i] === 'A') {
      let nextIndex = i + 1;

      while (nextIndex < name.length && name[nextIndex] === 'A') {
        nextIndex++;
      }

      const moveCount =
        (i - 1) * 2 + name.length - nextIndex;

      minMove = Math.min(minMove, moveCount);
    }

    answer += minMove;

    return answer;
}

Code Flow

• 먼저, index[0]부터 올바른 알파벳으로 가려면 위/아래에서 최단경로가 어느거냐부터 생각해야함. 그래서 alphabet이란 문자열을 미리 만들고, 최소 조작횟수를 기록함.

• 그 다음 for문을 돌면서 up down을 통해 해당 값에 먼저 도달하는지? 에 대해서 하고서 Math.min을 통해 가장 작은 값을 골라내야함.

• 그 다음 index[1]로 넘어가야 하니까 move함수를 만들고, index.length - 1 해줌( 초기값은 제외해야함),

• 그리고 다시 for문 돌려서, 찾는데, name[i]가 A면 그냥 통과시키고, 나머지면

다른 해답은 없을까?

function solution(name) {
  let answer = 0;
  let arr = [0];

  for (let i = 0; i < name.length; i++) {
    if (name[i] === "A") {
      // A가 나오는 경우 연속적으로 나온 A의 갯수를 계산한다.
      if (i === 0) {
        arr.push(calculateRepeatingA(name) - 1);
      } else if (name[i - 1] !== "A") {
        // 연속된 A의 숫자가 현재 index+1보다 큰 경우 차이를 빼서 반대로 돌아간 효과를 준다.
        arr.push(calculateRepeatingA(name.slice(i)) - (i - 1));
      }
      answer++;
    } else {
      answer += calculateCount(name[i]) + 1; // 해당 문자의 자릿수만큼 계산을 하며 오른쪽으로 이동한다.
    }
  }

  return answer - Math.max(...arr) - 1; // 마지막은 오른쪽으로 이동할 필요가 없기에 1을 빼준다.
}

function calculateCount(value) {
  // 현재 문자까지 필요한 조이스틱 이동 횟수를 계산
  return value.charCodeAt() - 65 < 91 - value.charCodeAt()
    ? value.charCodeAt() - 65
    : 91 - value.charCodeAt();
}

function calculateRepeatingA(name) {
  // 연속으로 나오는 A의 갯수를 계산
  let count = 0;
  for (let i = 0; i < name.length; i++) {
    if (name[i] !== "A") break;
    count++;
  }
  return count;
}

어떤 숫자에서 k개의 수를 제거했을 때 얻을 수 있는 가장 큰 숫자를 구하려 합니다.

• 예를 들어, 숫자 1924에서 수 두 개를 제거하면 [19, 12, 14, 92, 94, 24] 를 만들 수 있습니다. 이 중 가장 큰 숫자는 94 입니다.
• 문자열 형식으로 숫자 number와 제거할 수의 개수 k가 solution 함수의 매개변수로 주어집니다. number에서 k 개의 수를 제거했을 때 만들 수 있는 수 중 가장 큰 숫자를 문자열 형태로 return 하도록 solution 함수를 완성하세요.

제한 사항

• number는 2자리 이상, 1,000,000자리 이하인 숫자입니다.
• k는 1 이상 number의 자릿수 미만인 자연수입니다.

입출력 예

내가 푼 답

function solution(number, k) {
  const Arr1 = []; 

  for (let i = 0; i < number.length; i++) {
    const current = number[i];

    while (k > 0 && Arr1.length > 0 && Arr1[Arr1.length - 1] < current) {
      Arr1.pop(); 
      k--;
    }
    Arr1.push(current); 
  }

  if (k > 0) {
    Arr1.splice(-k, k);
  }

  return Arr1.join(''); 
}

Code Flow

생각하기

• number는 백만자리 미만의 자연수고, k가 number.length 미만일때, 가장 큰 수를 만들어야한다.
• 그렇다면 greedy가 맞다. 처음숫자 가장 큰거, 그 다음 큰거, 그 다음 큰거, 그 다음 큰거 식으로 진행된다.
• 처음에 자른 배열 중에서 가장 큰수가 들어가고, 그다음 큰 수, 그리고 그 다음 큰 수가 들어간다.
• 근데 여기서 주의해야 할 점은, k만큼 빼내야하므로 k카운트가 가득차면 더이상 빼낼 수 없다는 점임.
• 예시1을 예시로 보자, (...number) 했을때, 9,4가 들어가야하며, 이는 가장 큰 수부터 차례대로 빼내는게 맞다.
• 예시2를 예시로 보자, (...number) 했을때, 4가 먼저 나와야하지만, 4를 빼냈을 때 뒤가 없으니까, 3이 나와야한다.
• 그렇다면 k 카운트만큼 뒤의 배열이 남기도 해야함. 예시 2의 경우 234. 그러니 K를 하나씩 빼주자.
• 예시3을 예시로 보자, (...number) 했을때, 7이 먼저 들어가야하는데, 4가 먼저 들어갈 거다. , 그 뒤에 쭉 배열카운트보다 작은것들을 제외해준다

문제점 : k가 남았을때는 어떻게 해야할까?

• k가 0보다 크다면, 뒤에서부터 k를 봐서 가장 작은거부터 지워주게 한다. splice()함수를 이용해도 되고, lastindexOF를 사용해도 된다.
• 예시3을 풀이방법대로 풀면, "7" "7", "2", "5", "2", "8", "4", "1" 가 남는다, 이 경우엔 뒤에서부터 "1", "2"가 지워진다.

풀이를 좀 더 간결하게 해보자.

다른 해답은 없을까?

function solution(number, k) {
    const answer = []
    let head = 0
    let del = k

    answer.push(number[head++])
    while(answer.length < number.length - k || head < number.length) {
        if(del && answer[answer.length-1] < number[head]) {
            answer.pop()
            del--
            continue
        }
        answer.push(number[head++])
    }

    return answer.slice(0, number.length - k).join('')
}

• 기본적인 방법은 동일하되, 마지막에 slice를 통해 완성해주었다.

영어 대소문자로 이루어진 문자열 my_string이 매개변수로 주어질 때, my_string을 모두 소문자로 바꾸고 알파벳 순서대로 정렬한 문자열을 return 하도록 solution 함수를 완성해보세요.

제한 사항

• 0 < my_string 길이 < 100

입출력 예

입출력 예 설명

• 입출력 예 #1

  "Bcad"를 모두 소문자로 바꾸면 "bcad"이고 이를 알파벳 순으로 정렬하면 "abcd"입니다.

• 입출력 예 #2

  "heLLo"를 모두 소문자로 바꾸면 "hello"이고 이를 알파벳 순으로 정렬하면 "ehllo"입니다.

• 입출력 예 #3

  "Python"를 모두 소문자로 바꾸면 "python"이고 이를 알파벳 순으로 정렬하면 "hnopty"입니다.

내가 푼 답

function solution(my_string) {
    return [...my_string.toLowerCase()].sort().join(''); 
}

Code Flow

가장 중요하게 생각한 것

1. 모두 소문자로 바꿔야한다는 점. => toLowerCase() 를 사용해보자
2. sort()를 이용하면 사전순 정렬이 된다. 는걸 알고있음.

생각해본 것

• 그렇다면 spread를 통해 분철해주고 이걸 모두 소문자로 바꾸려면 toLowercase 함수를 쓰면 된다. 그리고 sort() 해준 후에, 다시 join() 으로 묶어주면 되나?

다른 해답은 없을까?

const solution = (my_string) => {
  let answer = "";
  answer = my_string.toLowerCase().split("").sort().join("");
  return answer;
};

• 나랑 다른점은 split() 으로 분할했다는 것.

split() : 문자열만 분할할 수 있으며, split([separator[, limit]] 값을 가진다.

• separator : 구분자(뭐로 자를 것인가).
• limit : 배열의 최대 길이 지정.

어떤 세균은 1시간에 두배만큼 증식한다고 합니다. 처음 세균의 마리수 n과 경과한 시간 t가 매개변수로 주어질 때 t시간 후 세균의 수를 return하도록 solution 함수를 완성해주세요.

제한 사항

• 1 ≤ n ≤ 10
• 1 ≤ t ≤ 15

입출력 예

입출력 예 설명

• 입출력 예 #1

  처음엔 2마리, 1시간 후엔 4마리, 2시간 후엔 8마리, ..., 10시간 후엔 2048마리가 됩니다. 따라서 2048을 return합니다.

• 입출력 예 #2

  처음엔 7마리, 1시간 후엔 14마리, 2시간 후엔 28마리, ..., 15시간 후엔 229376마리가 됩니다. 따라서 229,376을 return합니다.

  내가 푼 답

function solution(n, t) {
    for ( let i = 1; i <= t; i++ ) {
        n *= 2
    }
    return n;
}

Code Flow

• 가장 중요한 것
  • n마리가 t시간만큼 증가한다는 점. 즉 n *= 2 라는게 기본 골자.

• 생각해 본것.
  • 처음에는 제곱만큼 증가한다고 생각했는데, 생각해보니 아니었음.
  • 알고보니, t의 시간은 그냥 매개변수에 불과하고, 2배씩 증가한다는게 중요했음.

다른 해답은 없을까?

const solution = (n, t) => new Array(t).fill(n).reduce((a,b) => a*2,n)

1. new Array(t) 를 사용하여 길이가 t 인 새로운 배열을 생성합니다.
2. fill(n) 을 사용하여 배열을 n 으로 채웁니다. 이렇게 하면 배열의 각 요소가 n 값으로 초기화됩니다.
3. reduce 함수를 사용하여 배열의 모든 요소를 순회하고, 각 요소를 a 와 b로 가져와서 a * 2 를 반환합니다. 이 작업은 배열의 모든 요소를 곱한 뒤, 최종적으로 하나의 값을 반환합니다.

근데 이렇게 푸는거 너무 어려운듯..

공부할 것

• New 함수 : 객체 생성자 함수를 호출하여 새로운 객체를 생성하는 데 사용됩니다. 예를 들어, new 를 사용하여 새로운 배열, 객체, 함수 등을 만들 수 있습니다.

• fill 함수 : 배열의 모든 요소를 지정된 값으로 채우는 데 사용됩니다. 이 메서드는 원래 배열을 변경하고, 변경된 배열을 반환합니다.

• reduce 함수 : 배열의 각 요소에 대해 주어진 함수를 실행하고, 이전 요소의 결과와 현재 요소를 결합하여 최종 결과를 반환합니다.

어떤 자연수를 제곱했을 때 나오는 정수를 제곱수라고 합니다. 정수 n이 매개변수로 주어질 때, n이 제곱수라면 1을 아니라면 2를 return하도록 solution 함수를 완성해주세요.

제한사항

• 1 ≤ n ≤ 1,000,000

입출력 예

입출력 예 설명

입출력 예 #1

• 144는 12의 제곱이므로 제곱수입니다. 따라서 1을 return합니다.

입출력 예 #2

• 976은 제곱수가 아닙니다. 따라서 2를 return합니다.

내가 푼 답

function solution(n) {
    return Math.sqrt(n) % 1 === 0 ? 1 : 2
}

code flow

가장 중요한 것

• 제곱수를 판별해야한다.

그 다음으로 든 생각

• 이것도 역시 Boolean 값 ? true : false / 1 : 2 반환하는 것을 사용하자.
• 제곱근을 구하기 위해선 n을 무한히 나눠줘야한다.
• 무한히 나눠주는것은 끝이 없다, 다른 해법은 없을까?
• 그렇다면 Math.sqrt() 라는 함수를 사용해보자.

다른 해답은 없을까?

function solution(n) {
    const result = Math.pow(n, 0.5); 
    if (Number.isInteger(result)) {
        return 1;
    } else {
        return 2;
    }
}

배워둬야 할 것

• Math.pow() : 첫 번째 매개변수를 두 번째 매개변수로 제곱하는 역할을 하는 함수. Math.sqrt() 가 제곱근을 구한다면, Math.pow()는 거듭제곱을 한다. => 이게 왜 다른건가?
• isInteger : 주어진 값이 정수인지 여부를 확인하는 메서드.
  • Why? : 부동 소수점 숫자와 정수를 구별하기 위해서입니다.

문자열 str1, str2가 매개변수로 주어집니다. str1 안에 str2가 있다면 1을 없다면 2를 return하도록 solution 함수를 완성해주세요

제한 사항

• 1 ≤ str1의 길이 ≤ 100
• 1 ≤ str2의 길이 ≤ 100
• 문자열은 알파벳 대문자, 소문자, 숫자로 구성되어 있습니다.

입출력 예

입출력 예 설명

• 입출력 예 #1

  "ab6CDE443fgh22iJKlmn1o" str1에 str2가 존재하므로 1을 return합니다.

• 입출력 예 #2

  "ppprrrogrammers" str1에 str2가 없으므로 2를 return합니다.

• 입출력 예 #3

  "AbcAbcA" str1에 str2가 없으므로 2를 return합니다.

내가 푼 답

function solution(str1, str2) {
    return str1.indexOf(str2) != -1 ? 1 : 2;

}

Code Flow

가장 중요한 것

• str1안에 str2이 '묶여서' 있느냐? 를 파악해야 했다.

그 다음으로 생각해 본 것들

• 정규식을 활용하면 되지 않을까? /str2/g 이런건 안됨?
• indexof() 써서 앞에서부터 찾아나가는거.. 어떨까?
• ? true : false써서, 1 : 2 이렇게 쓰면 될 듯 했다.

다른 해답은 없을까?

function solution(str1, str2) {

  return str1.includes(str2)?1:2;
}

include 함수를 쓸 수도 있구나 생각 했다.

• include : 함수 안에 특정 요소가 포함되어 있는지 확인하는 함수. Boolean 값으로 나온다.

숫자와 "Z"가 공백으로 구분되어 담긴 문자열이 주어집니다. 문자열에 있는 숫자를 차례대로 더하려고 합니다. 이 때 "Z"가 나오면 바로 전에 더했던 숫자를 뺀다는 뜻입니다. 숫자와 "Z"로 이루어진 문자열 s가 주어질 때, 머쓱이가 구한 값을 return 하도록 solution 함수를 완성해보세요.

제한사항

• 1 ≤ s의 길이 ≤ 200
• -1,000 < s의 원소 중 숫자 < 1,000
• s는 숫자, "Z", 공백으로 이루어져 있습니다.
• s에 있는 숫자와 "Z"는 서로 공백으로 구분됩니다.
• 연속된 공백은 주어지지 않습니다.
• 0을 제외하고는 0으로 시작하는 숫자는 없습니다.
• s는 "Z"로 시작하지 않습니다.
• s의 시작과 끝에는 공백이 없습니다.
• "Z"가 연속해서 나오는 경우는 없습니다.

입출력 예

입출력 예 설명

입출력 예 #1

본문과 동일합니다.

입출력 예 #2

10 + 20 + 30 + 40 = 100을 return 합니다.

입출력 예 #3

"10 Z 20 Z 1"에서 10 다음 Z, 20 다음 Z로 10, 20이 지워지고 1만 더하여 1을 return 합니다.

입출력 예 #4, #5

설명 생략

내가 풀은 답

function solution(s) {
  const answer = [];

  for (const num of s.split(" ")) {
      if (num === "Z") {
          answer.pop();
      } else {
          answer.push(+num)
      }
  }
  return answer.reduce((a,b) => a + b, 0);
}

더 괜찮은 답은 없었을까?

function solution(s) {
    s = s.split(" ")
    // Z가 있다면, 이전것과 같이 삭제
    while(s.includes('Z')) {
        s.splice(s.indexOf('Z')-1,2)
    }
    return s.reduce((a,b) => a+Number(b), 0)
}

왜 이렇게 생각했나요?

1. Z가 나오면 뒤의 원소 - 앞의 원소. 지만, 나오지 않으면 그냥 다 더하고 끝이야.
2. Z가 여러개 나올 수도 있다. 그치만 연속은 아니다.
3. 배열에다가 함수[0] (함수[1]) 함수[2]하는걸 생각해봤을때, 함수[1]값을 따로 빼내주면 되는게 아닌가? 하고 생각했다.

풀이 과정.

1. 빈 배열 answer를 먼저 만들어준다.
2. 지정되어 있는 문자열 s를 split함수를 이용하여 " " 로 분할해주고
3. 그다음 for...of 를 사용하여 반복처리해준다. 여기서 num은 현재 요소를 의미한다.
4. 그 후 num === z(기호인가?) 인가를 파악하고, 맞으면 pop(없애고), 틀리면 +num을 통해 숫자로 변환하고, 숫자를 푸시한다.
5. 완성되고 나선 reduce() 함수를 이용하여 모든 숫자요소의 합계를 더한다.
6. profit!

후기.

생각보다 어려운 문제였다. 2번까지는 잘 생각해냈는데, 4번 과정을 손으로 옮기는 과정이 어려웠다. 이거랑 비슷한 문제가 있었던 것 같은데?