holajjm

[문제 링크]

https://leetcode.com/problems/shuffle-string/submissions/1291926705/

[문제 사고]

주어진 문자열과 배열의 동일한 인덱스를 짝지어 오름차순으로 정렬한 문자열을 반환한다.

[문제 해결]

1. 빈 배열 answer을 생성한다.
2. 주어진 문자열과 배열의 길이만큼 반복문을 순회하며 answer 배열에 indices와 문자열 s를 순차적으로 짝지어 indices 값을 인덱스 값으로 지정 후 넣어준다.
3. answer 배열을 join method를 사용하여 정답을 반환한다.

[작성 코드]

/**
 * @param {string} s
 * @param {number[]} indices
 * @return {string}
 */
var restoreString = function(s, indices) {
    const answer = [];
    for(let i = 0; i < s.length; i++){
        answer[indices[i]] = s[i]
    }
    return answer.join('')
};

[문제 회고]

생각보다 간단한 문제였는데 처음에 풀었을 때, 메모리 공간 차지를 매우 많이하게 했다. 문자열을 split하여 사용할까 했었지만 String 자료형의 특징을 파악하면 문자열에도 인덱스가 존재하기 때문에 배열과 짝지어 쉽게 풀 수 있었다.

[문제 링크]

https://leetcode.com/problems/count-items-matching-a-rule/

[문제 사고]

주어진 key 값에 따라 이중 배열의 내부 배열의 해당 key 값을 찾아 일치하는 값이 있으면 그만큼의 값을 반환한다.

[문제 해결]

1. 정답을 담을 변수 answer을 선언 후 0을 할당한다.
2. 3개의 조건문을 생성하여 ruleKey 값 각각의 경우에 따라 items 배열을 순회하는 코드를 작성한다.
3. key 값이 type이면 내부 배열의 0번째 인덱스, color이면 1번째, name이면 2번째 인덱스 값들을 비교한다.
4. 누산값이 들어있는 answer 변수를 반환한다.

[작성 코드]

/**
 * @param {string[][]} items
 * @param {string} ruleKey
 * @param {string} ruleValue
 * @return {number}
 */
var countMatches = function(items, ruleKey, ruleValue) {
    let answer = 0;
    if(ruleKey === "type") items.map(e => e[0] === ruleValue ? answer++ : null);
    if(ruleKey === "color") items.map(e => e[1] === ruleValue ? answer++ : null);
    if(ruleKey === "name") items.map(e => e[2] === ruleValue ? answer++ : null);
    return answer;
};

[문제 회고]

이중 배열이라고 복잡하게 생각할 것이 없이 주어진 key 값을 잘 활용하여 배열을 다루면 간단하게 해결되는 문제였다.

[문제 링크]

https://leetcode.com/problems/find-words-containing-character/description/

[문제 사고]

주어진 배열을 순회하며 각 요소가 주어진 타겟 값을 포함하고 있으면 해당 값의 인덱스들을 모아 배열을 반환한다.

[문제 해결]

1. 정답으로 반환할 answer 배열을 선언한 후 빈 배열을 할당해준다.
2. 주어진 words 배열을 순회하며 각 문자열 요소가 주어진 x 문자열을 포함하고 있다면 answer 배열에 해당 요소의 인덱스 값을 넣어준다.
3. answer 배열을 반환한다.

[작성 코드]

/**
 * @param {string[]} words
 * @param {character} x
 * @return {number[]}
 */
var findWordsContaining = function(words, x) {
    const answer = [];
    words.map((e,i) => e.includes(x) ? answer.push(i) : null );
    return answer;
};

[문제 회고]

배열이 무엇인지 알고 method들을 잘 알고 활용할 줄 안다면 쉽게 풀이할 수 있는 문제였다. 처음에 내부 요소들을 split 하여 하나하나 순회하려고 하였지만 메모리 공간을 효율적으로 사용하기 위해 words 배열을 직접적으로 사용하였다. 시간 복잡도와 공간 복잡도를 고려하여 만족스럽게 풀었던 것 같다.

[문제 링크]

https://leetcode.com/problems/number-of-good-pairs/description/

[문제 사고]

주어진 배열의 인덱스가 겹치지 않게 이중반복문을 돌면서 순서쌍을 생성하여 주어진 조건에 충족하는 경우의 수를 반환한다.

[문제 해결]

1. 정답을 담을 변수 answer을 선언하고 0을 할당한다.
2. nums 배열을 이중 반복문을 통해 돌면서 인덱스가 겹치지 않도록 한다.
3. 이중 반복문을 이용해 순서쌍의 첫번째 인자와 두번째 인자의 값이 같다면 answer 값을 증가시킨다.
4. answer 값을 반환한다.

[작성 코드]

/**
 * @param {number[]} nums
 * @return {number}
 */
var numIdenticalPairs = function(nums) {
    let answer = 0;
    for(let i = 0; i < nums.length - 1; i++){
        for(let j = i+1; j < nums.length; j++){
            nums[i] == nums[j] ? answer++ : null
        }
    }
    return answer
};

[문제 회고]

배열은 많이 다루어 보았기 때문에 문제 해결에 어려움은 없었다. 하지만 이중 반복문으로 풀었기에 시간 복잡도가 좋은 편은 아니였다. 시간 복잡도를 개선할 수 있는 방식이 있는지 파악해볼 예정이다.

[문제 링크]

https://leetcode.com/problems/shuffle-the-array/description/

[문제 사고]

배열을 다루는 method를 활용하여 주어진 조건에 맞는 배열을 생성하여 반환한다.

[문제 해결]

1. 주어진 배열을 n의 길이만큼 앞뒤로 잘라서 새로운 변수에 할당해준다.
2. 정답으로 반환할 빈 배열을 선언해준다.
3. 반복문을 n까지 돌면서 각 배열의 첫번째 요소부터 차례대로 정답 배열에 넣어준다.
4. 정답 배열을 반환한다.

[작성 코드]

/**
 * @param {number[]} nums
 * @param {number} n
 * @return {number[]}
 */
var shuffle = function(nums, n) {
    const first = nums.slice(0,n);
    const second = nums.slice(n,nums.length);
    const answer = [];
    for(let i = 0; i < n; i++){
        answer.push(first[i]);
        answer.push(second[i])
    }
    return answer
};

[문제 회고]

기초적인 배열을 다루는 문제라서 어렵지 않았다. 코드를 더 단축시킬 수 있는 방법도 고민해볼 예정이다.

[문제 링크]

https://leetcode.com/problems/minimum-number-of-moves-to-seat-everyone/submissions/1286580853/?envType=daily-question&envId=2024-06-13

[문제 사고]

주어진 두 배열을 정렬 후 동일한 인덱스 값의 차들을 합하여 반환한다.

[문제 해결]

1. 주어진 두 배열을 오름차순으로 정렬한 배열을 각각 새로 선언해준다.
2. 정답을 넣을 임의의 변수 answer을 선언한 후 0을 할당해준다.
3. 주어진 배열의 길이만큼 반복문을 돌면서 정렬된 배열의 각 인덱스 값의 차를 구한다.
4. 삼항 연산자를 통해 두 값 중 큰 값에서 작은 값을 빼도록 작성한다.
5. 각 값들의 차가 모두 더해진 answer 변수를 반환한다.

[작성 코드]

/**
 * @param {number[]} seats
 * @param {number[]} students
 * @return {number}
 */
var minMovesToSeat = function(seats, students) {
    const newSeats = seats.sort((a,b) => a - b);
    const newStudents = students.sort((a,b) => a - b);
    let answer = 0;
    for(let i = 0; i < seats.length; i++){
        answer += (newStudents[i] >= newSeats[i] ? newStudents[i] - newSeats[i] : newSeats[i] - newStudents[i])
    }
    return answer;
};

[문제 회고]

오늘은 시간이 부족했기에 특정 알고리즘이나 그래프 자료구조를 활용하지 않고 하드 코딩하여 구현하였다. 추후에 그래프를 활용하여 문제를 풀어보며 연습을 해 볼 예정이다. 그럼에도 오늘 단순 구현하여 푼 코드가 효율성도 좋고 메모리 효율성도 나쁘지 않았다.

[문제 링크]

https://leetcode.com/problems/find-center-of-star-graph/

[문제 사고]

주어진 이중 배열을 순회하며 내부 배열들의 요소들중 공통적인 값을 찾아낸다.

[문제 해결]

Solution - 1
1. edges 배열의 길이 값을 담아둔 변수 하나와 Map 객체를 담아둘 변수를 선언해준다.
2. edges 배열을 순회하며 각 내부 배열들을 새로운 변수에 구조 분해 할당을 통해 담아둔다.
3. Map 객체에 key 값에 내부 배열의 각 요소를, value 값에 빈 배열을 넣어준다.
4. key 값에 해당하는 빈 배열을 갖고 온 후 내부 배열의 쌍에 맞게 빈 배열에 push 해준다.
5. 정답을 반환할 임의의 변수 answer을 선언한 후 map 객체를 순회하며 빈 배열에 들어있는 값의 개수와 edges 배열의 길이 값과 같다면 해당 key 값을 answer에 넣어준 후 반환한다.

Solution - 2
1. 정답으로 반환할 변수 answer을 선언 후 0을 할당해준다.
2. edges 배열의 각 요소의 인덱스와 다음 인덱스의 값을 비교하기 위해 0부터 (edges 배열의 길이 - 1)까지 반복문을 돈다.
3. 각 요소 별로 순회하며 다음 인덱스의 값들과 각각 비교하며 일치하는 값이 있다면 answer에 넣어준 후 반환한다.

[작성 코드]

/**
 * @param {number[][]} edges
 * @return {number}
 */
var findCenter = function(edges) {
    //Solution - 1
    const n = edges.length;
    const map = new Map();
    for(let i = 0; i < n; i++){
        const [a,b] = edges[i];
        if(!map.has(a)) map.set(a,[]);
        if(!map.has(b)) map.set(b,[]);
        map.get(a).push(b);
        map.get(b).push(a);
    }
    let answer = 0;
    map.forEach((e,i) => {
        if(e.length === n) answer = i;
    })
    return answer;
    //Solution - 2
    let answer = 0;
    for(let i = 0; i < edges.length-1; i++){
        edges[i].map(e => edges[i+1].map(e1 => e === e1 ? answer = e1 : null))
    }
    return answer;
};

[문제 회고]

자바스크립트로 그래프 자료구조를 구현하고 문제를 풀어내는 것에 익숙치 않았다. 그래프 자료구조를 이해는 하고 있지만 어떤 알고리즘을 사용하여 해결해야 하는지에 대해 공부할 수 있었던 문제였다. 하지만 문제의 난이도가 easy여서 그런지 특정 알고리즘을 사용한 것보다 하드 코딩하여 구현한 코드가 시간 복잡도와 공간 복잡도가 더 좋게 나타나는 모습을 보였다.

[문제 링크]

https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/description/

[문제 사고]

주어진 이중 배열을 순회하며 각 요소별로 이분 탐색을 통해 조건에 맞는 요소의 개수를 반환한다.

[문제 해결]

Solution - 1
1. 정답을 반환할 임의의 변수 answer을 선언하고 0을 할당한다.
2. grid 배열을 순회하며 각 요소인 내부 배열에 하나씩 접근한다.
3. 각 배열마다 이분 탐색을 진행한다.
4. 이분 탐색을 통해 내부 배열의 요소가 음수인 경우 answer을 1씩 증가해준다.
5. 정답 answer을 반환한다.

Solution - 2
1. 정답을 반환할 임의의 변수 answer을 선언하고 0을 할당한다.
2. 이중 반복문을 통해 이중 배열을 순회하며 각 요소의 값이 음수인 경우 answer의 값을 증가시키는 삼항 연산식을 작성한다.
3. 정답 answer을 반환한다.

[작성 코드]

/**
 * @param {number[][]} grid
 * @return {number}
 */
var countNegatives = function(grid) {
    //sol - 1
    let answer = 0
    for(const value of grid){
        let lo = 0
        let hi = value.length - 1
        while (lo <= hi){
            const mid = Math.floor(lo + (hi - lo) / 2 )
            if (value[mid] < 0){
                answer += hi - mid + 1
                hi = mid - 1
            }else{
                lo = mid + 1
            }
        }
    }
    return answer
    //sol - 2
    let answer = 0;
    for(let i = 0; i<grid.length;i++){
        for(let j = 0; j<grid[0].length;j++){
            grid[i][j] < 0 ? answer++ : null
        }
    }
    return answer;
};

[문제 회고]

이분 탐색의 풀이에 대해 좀 익숙해져서 이분 탐색 알고리즘을 사용하는데에 어려움은 없었지만 디테일 함이 부족하다는 것을 느꼈다. 또한 이분 탐색보다 이중 반복문을 통해 구현을 하였을 때 더 효율적으로 보였지만 시간 복잡도와 공간 복잡도를 따져보며 다시 공부를 해보며 이분 탐색의 장점을 생각해 볼 필요성을 느꼈다.

[문제 링크]

https://leetcode.com/problems/search-insert-position/description/

[문제 사고]

주어진 배열을 이분 탐색하여 주어진 목표값에 해당하는 배열의 index 값을 반환한다.

[문제 해결]

Solution - 1
1. 이분 탐색을 위한 first 값과 last 값을 선언 후 각 의미에 맞는 값을 할당해준다.
2. target 값이 nums 배열에 포함되어있지 않다면 nums 배열에 push 해주고 오름차순으로 배열을 정렬해준다.
3. 이분 탐색을 통해 target 값을 찾은 후 target 값의 index 값을 반환한다.

Solution - 2
1. target 값이 nums 배열에 포함되어있지 않다면 nums 배열에 push 해주고 오름차순으로 배열을 정렬해준다.
2. nums 배열 안에서 target 값의 인덱스 값을 indexOf method를 사용하여 반환한다.

[작성 코드]

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var searchInsert = function(nums, target) {
    //sol-1
    let first = 0;
    let last = nums.length - 1;
    if(!nums.includes(target)) nums.push(target)
    nums.sort((a,b) => a - b);
    while(first <= last){
        let mid = Math.floor((first+last) / 2);
        if(nums[mid] === target){
            return mid
        }else if(nums[mid] > target){
            last = mid - 1;
        }else if(nums[mid] < target){
            first = mid + 1;
        }
        return nums.indexOf(target)
    }
    //sol-2
    if(!nums.includes(target)) nums.push(target);
    nums.sort((a,b) => a - b);
    return nums.indexOf(target)
};

[문제 회고]

이분 탐색을 구현하는 가장 기초적인 문제였다. 이분 탐색으로 구현하여 답을 도출해내는 데에는 무리가 없었지만 문제 자체가 너무 기본적인 문제라서 이분 탐색을 사용할 필요도 없이 더 효율적인 방법이 있어서 2번 풀이로도 풀어보았다. 이분 탐색 알고리즘에 대한 이해도가 조금 쌓인 것 같다.

[문제 링크]

https://leetcode.com/problems/divisor-game/description/

[문제 사고]

정해진 규칙에 따라서 올바른 Boolean 값을 찾아내어 반환한다.

[문제 해결]

1. n이 짝수인 경우에 Alice가 이기는 경우가 발생하고 n이 홀수인 경우 Bob이 이기는 경우가 발생한다.
2. n이 짝수이면 true, 홀수이면 false를 반환하는 코드를 작성한다.

[작성 코드]

/**
 * @param {number} n
 * @return {boolean}
 */
var divisorGame = function(n) {
    return n % 2 === 0 ? true : false;
};

[문제 회고]

문제를 처음 이해했을 때에는 복잡한 과정이 있을 것 같았지만 몇 번의 테스트를 거쳐보니 아주 쉬운 규칙이 나와서 한 줄로 코드가 완성이 되었다. DP를 제대로 구현해서 문제를 다시 풀어볼 계획이다.