holajjm

[문제 링크]

https://leetcode.com/problems/maximum-odd-binary-number/submissions/1302548871/

[문제 사고]

주어진 문자열을 조건에 맞게 재구성한 후 반환한다.

[문제 해결]

1. 주어진 문자열을 split method를 통해 분리한 후 내림차순으로 정렬해준다.
2. 문제의 조건에 충족하기 위해 가장 앞에 있을 요소 '1'을 하나 shift 해준다.
3. 정렬되어있던 문자열 배열에 빼내었던 요소 '1'을 가장 뒤에 push 해준다.
4. 문자열 배열을 join method를 통해 문자열로 변환 후 반환한다.

[작성 코드]

/**
 * @param {string} s
 * @return {string}
 */
var maximumOddBinaryNumber = function(s) {
    const word = s.split('').sort((a,b) => b - a);
    const one = word.shift();
    word.push(one)
    return word.join('')
};

[문제 회고]

간단한 마지막 문제였다. 주어진 문자열을 오름차순이 아닌 내림차순으로 정렬하여 코드의 길이를 최소화 하였다.

[문제 링크]

https://leetcode.com/problems/the-k-weakest-rows-in-a-matrix/

[문제 사고]

주어진 조건에 따라 값을 오름차순으로 정렬한 후 해당 인덱스를 구한 후 일정 범위까지의 배열을 반환한다.

[문제 해결]

1. 정답을 넣을 빈 배열 result를 생성한다.
2. mat 배열을 순회하며 내부 배열을 1의 개수로 변환한다.
3. 변환된 배열을 순회하며 인덱스와 요소를 한 쌍의 배열로 만들어주고 요소를 오름차순으로 정렬한 후 인덱스 값만 result 배열에 넣어준다.
4. result 배열을 k까지 자른 후 반환한다.

[작성 코드]

/**
 * @param {number[][]} mat
 * @param {number} k
 * @return {number[]}
 */
var kWeakestRows = function(mat, k) {
    const result = [];
    const arr = mat.map(e => e = e.filter(e => e === 1).length);
    const answer = arr.map((e,i) => e = [i,e]).sort((a,b) => a[1]-b[1]).map(e => result.push(e[0]))
    return result.splice(0,k)
};

[문제 회고]

문제 자체가 어렵지는 않았지만 heap을 구현하지는 못했다. 그래서 불필요한 반복과 복잡한 method를 많이 사용하게 되었다. 효율성과 메모리를 고려해서 heap을 사용해서 다시 풀어볼 예정이다.

[문제 링크]

https://leetcode.com/problems/delete-greatest-value-in-each-row/submissions/1300443889/

[문제 사고]

주어진 다중 배열을 순회하며 조건에 맞는 수를 도출하여 연산한 값을 반환한다.

[문제 해결]

1. 내부 배열들을 오름차순으로 정렬하여 새로운 배열을 반환한다.
2. 정답 값을 넣을 변수 answer을 선언 후 0을 할당한다.
3. 내부 배열의 길이만큼 반복문을 돌면서 임의의 빈 배열 arr에 내부 배열의 pop() 값을 넣어준다.
4. answer 변수에 arr 배열의 최대 값을 더해준다.
5. 정답 answer을 반환한다.

[작성 코드]

/**
 * @param {number[][]} grid
 * @return {number}
 */
var deleteGreatestValue = function(grid) {
    const newGrid = grid.map(e => e.sort((a,b) => a - b));
    let answer = 0;
    while(newGrid[0].length){
        let arr = [];
        for(let value of newGrid){
            arr.push(value.pop())
        }
        answer += Math.max(...arr)
    }
    return answer;
};

[문제 회고]

자료구조 힙을 제대로 구현했는지는 잘 모르겠다. 아직 익숙치 않고 어려운 부분이 있어서 자료구조에 얽메이지 않고 구현을 해내는 데에 집중하였다. 단일 반복문을 통해서 풀어보려했지만 쉽지 않았기에 시간 복잡도에 큰 문제가 없어 이중 반복문을 사용하였다.

[문제 링크]

https://leetcode.com/problems/baseball-game/submissions/1299398832/

[문제 사고]

주어진 배열을 순회하며 각 요소를 조건에 맞게 처리한 후 반환된 배열 내부 요소들의 합을 도출한다.

[문제 해결]

1. 정답을 담을 빈 배열 answer을 선언한다.
2. operations 배열의 길이만큼 반복문을 돌면서 내부 요소를 조건에 맞게 작업한다.
3. 숫자를 우선 처리하는 것이 아니라 "C","D","+" 세가지 문자열에 대한 조건을 먼저 처리해준다.
4. 그 이후 숫자들을 빈 배열에 넣어가며 연산 처리를 한다.
5. answer 배열을 반환 받은 뒤 내부 요소들의 총합을 구해 반환한다.

[작성 코드]

/**
 * @param {string[]} operations
 * @return {number}
 */
var calPoints = function(operations) {
    const answer = [];
    for(let i = 0; i < operations.length; i++){
        if(operations[i] === "C"){
            answer.pop();
        }else if(operations[i] === "D"){
            answer.push(+(answer[answer.length - 1]) * 2) 
        }else if(operations[i] === "+"){
            answer.push(+answer[answer.length - 1] + +answer[answer.length-2])
        }else{
            answer.push(+operations[i])
        }
    }
    return answer.reduce((a,b) => a + b,0)
};

[문제 회고]

스택과 큐에 관한 문제라고해서 주어진 배열의 맨 앞과 맨 뒤에서 조건 처리를 시작해야한다는 고정관념에 빠져있었다. 하지만 더 다양한 경우가 주어질 수 있는 숫자를 처리하는 것에 비해 연산과 조건 처리에 해당하는 세가지 문자열에 대한 조건문을 작성한 후 숫자 연산 작업을 하는 것이 효율적일 것이라 생각하여 코드를 짜보았다.

[문제 링크]

https://leetcode.com/problems/final-prices-with-a-special-discount-in-a-shop/submissions/1298369721/

[문제 사고]

주어진 배열의 각 요소를 주어진 조건에 맞게 연산하여 정답 배열을 반환한다.

[문제 해결]

1. 정답을 넣을 배열 answer을 선언 후 빈 배열을 할당해준다.
2. 이중 반복문을 돌면서 내부 반복문은 외부 반복문의 초기값을 1더한 값에서 시작한다.
3. prices 배열의 첫번째 요소의 값과 그 뒤 요소들을 돌면서 비교하여 첫번째 요소 값이 더 큰 경우는 두 값의 차를 정답 배열에 넣어주는 코드를 작성한다.
4. 정답 배열을 반환한다.

[작성 코드]

/**
 * @param {number[]} prices
 * @return {number[]}
 */
var finalPrices = function(prices) {
    const answer = []
    for(let i = 0; i < prices.length; i++){
        for(let j = i+1; j < prices.length;j++){
            if(prices[i] >= prices[j]){
                prices[i] = prices[i] - prices[j];
                break;
            }
        }
        answer.push(prices[i])
    }
    return answer;
};

[문제 회고]

스택과 큐 자료구조만을 생각했을 때 주어진 배열에서 요소를 빼며 반복문 하나로만 구현을 해낼 수 있을 것 같았지만 쉽지 않았기에 이중 반복문을 돌면서 쉽게 구현했다.

[문제 링크]

https://leetcode.com/problems/number-of-recent-calls/submissions/1297831

[문제 사고]

생성자 함수와 스택을 이용하여 주어진 조건에 충족하는 요소를 넣고 정답을 반환한다.

[문제 해결]

1. 생성자 함수에 정답에 해당하는 answer에 빈 배열을 할당하여 선언한다.
2. answer 배열에 t를 push하고 반복문을 돌면서 answer 배열의 첫번째 요소가 t - 3000 값보다 작은 값일 경우에 배열의 가장 앞의 요소를 제거한다.
3. 반복문을 돌고 남은 요소들이 들어있는 배열의 길이 값을 반환한다.

[작성 코드]

var RecentCounter = function() {
    this.answer = [];    
};

/** 
 * @param {number} t
 * @return {number}
 */
RecentCounter.prototype.ping = function(t) {
    this.answer.push(t);
    while(this.answer[0] < t - 3000){
        this.answer.shift();
    }
    return this.answer.length
};

/** 
 * Your RecentCounter object will be instantiated and called as such:
 * var obj = new RecentCounter()
 * var param_1 = obj.ping(t)
 */

[문제 회고]

많이 사용해보지 않은 생성자 함수를 갑작스레 다루어보니 당황스러웠지만 문제 자체의 난이도가 높지 않기 때문에 반복문과 스택을 이용해서 단순 구현을 하여 풀어낼 수 있었다.

[문제 링크]

https://leetcode.com/problems/number-of-students-unable-to-eat-lunch/submissions/1296240392/

[문제 사고]

각 배열의 자료구조 형태에 맞게 순회하며 조건을 충족하지 못한 요소들의 개수를 반환한다.

[문제 해결]

1. 임의의 변수 num을 선언한 후 0을 할당한다.
2. while 반복문을 순회하며 stack과 queue 형태의 배열의 각 요소를 차례로 꺼내어 비교해본다.
3. 요소가 같다면 두 배열에서 제외하고 같지 않다면 queue는 마지막 요소로 집어넣고 stack은 그대로 둔다.
4. 위 작업을 반복하면서 두 요소의 값이 일치하지 않는 경우에는 num 변수를 1 증가시킨다.
5. num의 값과 학생 배열의 길이 값이 같아진다면 반복문을 멈추고 남아있는 학생 수를 의미하는 학생 배열의 길이를 반환한다.

[작성 코드]

/**
 * @param {number[]} students
 * @param {number[]} sandwiches
 * @return {number}
 */
var countStudents = function(st, sa) {
    let num = 0;
    while(st.length){
        if(st[0] === sa[0]){
            st.shift();
            sa.shift();
            num = 0;
        }else{
            st.push(st.shift());
            num++
            if(num === st.length) break;
        }
    }
    return st.length
};

[문제 회고]

스택과 큐에 대한 이해도만 있다면 구현하는데에 어려움이 없는 문제였다. 하지만 반복문을 순회해야 한다는 점은 인지하였지만 while 문을 사용해야겠다는 생각을 초기에 하지 못했기에 오랜 시간이 걸렸다.

[문제 링크]

https://leetcode.com/problems/find-target-indices-after-sorting-array/

[문제 사고]

주어진 배열을 정렬 후 목표값과 일치하는 요소의 인덱스를 넣은 배열을 반환한다.

[문제 해결]

1. nums 배열을 오름차순으로 정렬한 새로운 배열 newNums를 생성한다.
2. 정답을 넣어 반환할 빈 배열 answer을 생성한다.
3. newNums 배열을 map method로 순회하며 요소가 target 값과 일치하면 answer 배열에 push 한다.
4. 정답이 담긴 answer 배열을 반환한다.

[작성 코드]

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var targetIndices = function(nums, target) {
    const newNums = nums.sort((a,b) => a - b);
    const answer = [];
    newNums.map((e,i) => {if(e === target) answer.push(i)});
    return answer
};

[문제 회고]

위의 방식대로 빠른 시간 내에 해결하였지만 메모리 효율과 시간의 최적화에 너무 강박이 씌인 것인지 어떻게든 두 가지 모두 줄여보려고 노력해보았지만 실패하였다. 배열 안의 특정 요소를 즉시 삭제하는 방법이 없기 때문에 최선의 방법으로 코드를 구현한 것 같다.

[문제 링크]

https://leetcode.com/problems/neither-minimum-nor-maximum/description/

[문제 사고]

주어진 배열을 정렬 후 문제의 조건에 맞는 요소를 반환한다.

[문제 해결]

1. 주어진 nums 배열을 오름차순으로 정렬한다.
2. 최소값과 최대값을 제외한 상태에서 가장 작은 요소를 반환하는 것이므로 배열의 길이에서 2를 제외한 후, 그 길이가 0 이하이면 -1을 반환, 그게 아니라면 배열의 1번 인덱스의 요소를 반환한다.

[작성 코드]

/**
 * @param {number[]} nums
 * @return {number}
 */
var findNonMinOrMax = function(nums) {
    const newNums = nums.sort((a,b) => a - b);
    return newNums.length - 2 <= 0 ? -1 : newNums[1];
};

[문제 회고]

효율적인 메모리 사용을 위해 필수 조건인 배열의 오름차순 정렬에만 시간과 메모리를 사용하고 반환하는 정답에는 가장 최적화 된 코드를 사용하여 구현하였다.

[문제 링크]

https://leetcode.com/problems/decode-the-message/description/

[문제 사고]

자료구조 해시 테이블,해시 맵을 사용해서 주어진 문자열의 각 인덱스에 상응하는 문자를 조합하여 정답을 반환한다.

[문제 해결]

1. a-z범위의 문자열을 임의의 변수를 선언하여 할당해준다.
2. 정답을 담을 변수와 Map 객체와 인덱스를 담을 변수 count를 선언해준다.
3. 주어진 key 값을 공백을 제외하고 분리하여 배열로 변환해준다.
4. 새로운 key 변수를 반복문을 통해 Map 객체에 key 값에 문자값을, value 값에 count 변수를 증가하면서 넣어준다.
5. 겹치는 문자가 없도록 예외처리를 함께 해준다.
6. message 변수를 반복문을 통해 돌면서 순차적으로 인덱스 값에 따라 영문자 문자열의 인덱스 값에 맞춰서 정답 변수에 넣어준다.
7. 공백이 있었다면 공백을 추가해주는 작업도 해준다.
8. 정답에 해당하는 변수를 반환한다.

[작성 코드]

/**
 * @param {string} key
 * @param {string} message
 * @return {string}
 */
var decodeMessage = function(key, message) {
    const eng = 'abcdefghijklmnopqrstuvwxyz';
    let answer = '';
    const newKey = key.split(' ').join('');
    const map = new Map();
    let count = 0;
    for(let value of newKey){
        if(!map.has(value)){
            map.set(value,count);
            count++
        }
    }
    for(let i = 0; i < message.length; i++){
        if(message[i] === ' '){
            answer += ' ';
            continue;
        }
        let index = map.get(message[i]);
        answer += eng[index];
    }
    return answer
};

[문제 회고]

예전에 사용했었던 해시 테이블과 해시 맵을 복습할 수 있는 문제였다. 단순히 문자열과 배열만을 사용해서 풀어보려 했지만 불필요한 메모리 사용과 시간 복잡도가 좋지 않을 것 같아 Map 객체를 사용하여 풀어보았다.