y_flm's Blog

function solution(s) {
    let str = s.split('');
    
    while(str.length > 0) {
        let findStr = false;
        if(str.length % 2 !== 0) return 0;
        
        for(let i = 0; i < str.length; i++) {
            if(str[i] === str[i + 1]) {
                str.splice(i, 2);
                findStr = true;
                break;
                }
            }
        if(!findStr) return 0;
        }
    
    return 1;
}

 처음에 작성한 코드이다. 테스트 케이스는 다 통과했지만 효율성 테스트는 통과하지 못했다.

아무래도 s의 길이가 최대 1,000,000이기 때문에 효율적인 코드가 필요한 것 같다.

단순히 처음부터 배열을 순회하며 현재 인덱스와 다음 인덱스가 같은지 확인하고 같다면 splice로 삭제하게끔 했다.

또한 문자열 길이가 홀수이거나 findStr 변수로 연속된 문자가 없을 경우 0을 리턴하도록 해줬다.

마지막에 while 문을 빠져나온다면 str 길이가 0일테니 1을 리턴해줬다.

아무래도 splice는 제거할 때마다 배열을 재구성하기 때문에 비효율적인 것 같다.

그래서 찾은 방법은 스택이다!

function solution(s) {
    let stack = [];
    
    for (let i = 0; i < s.length; i++) {
        if (stack.length > 0 && stack[stack.length - 1] === s[i]) {
            stack.pop();
        } else {
            stack.push(s[i]);
        }
    }

    return stack.length === 0 ? 1 : 0;
}

스택은 후입선출의 특징을 가지고 있으며 문자열의 요소를 하나씩 넣으며 비교할 수 있다.

따라서 먼저 스택이 비어있는지 확인하고, 현재 문자와 스택의 마지막 문자가 같은지 확인한다.

조건을 충족하면 짝지어있는 문자임으로 삭제해주고, 아니라면 스택에 push 해준다.

문제에서 알려준 예시인 baabaa로 적용해보면,

1. 스택에 b가 추가된다. => stack = ['b']

2. 그다음 a에 대하여, 들어있는 b와 a는 같지 않으므로 그대로 a가 스택에 추가된다. => stack = ['b', 'a']

3. a와 앞선 a는 같으므로 삭제해준다. => stack = ['b']

4. b와 앞선 b는 같으므로 삭제한다. => stack = []

5. 현재 스택은 비어있으므로 그냥 a가 추가된다. => stack = ['a']

6. 마지막으로 현재 a와 앞선 a가 같으므로 삭제된다. => stack = []

7. 스택이 비어있으므로 1이 리턴된다.

스택을 활용하면 더 효율적으로 문제를 해결할 수 있다.

2단계로 넘어오면서 더 다양하게 문제를 풀어야하겠구나 싶었다 ㅠ

function solution(n) {
    let value = {};
    
    for(let i = 2; i <= n; i++) {
        value[0] = 0;
        value[1] = 1;
        value[i] = (value[i - 1] + value[i - 2]) % 1234567;
    }
    
    return value[n];
}

처음에는 객체를 사용해서 맵핑 시켜주는 방식을 선택했다.

근데 이렇게 연속되는 인덱스 값에서는 객체보다는 배열이 효율적이라고 해서 배열로 바꿔주었다.

function solution(n) {
    let value = [0, 1];
    
    for (let i = 2; i <= n; i++) {
        value[i] = (value[i - 1] + value[i - 2]) % 1234567;
    }
    
    return value[n];
}

주의할 점은 return 값에만 value[n] % 1234567을 해줬었는데 그러면 value[n]의 값이 너무 커져서 오버플로우가 발생한다.

따라서 값을 저장할 때부터 % 1234567을 해주면서 값이 커지는 것을 방지해줘야한다!

이 문제는 예전에 푼 기록이 있었는데, 그래도 다시 한 번 풀어보았다!

function solution(t, p) {
    let value = [];
    let count = 0;
    
    for(let i=0; i<t.length - p.length + 1; i++) {
        value.push(t.slice(i, i + p.length))
    }
    
    value.map((item) => {
        if(Number(item) <= Number(p)) {
            count += 1;
        }
    })
    
    return count;
}

이전에는 이렇게 풀었었다.

slice를 활용해서 부분 문자열들을 value에 담아놓고 그 이후 map을 이용해 value 값을 순회하며 count를 해줬다.

지금 보면 다시 리턴할 배열도 없는데 왜 map을 썼는지,

굳이 value를 다 담아놓고 난 후에 count를 해줄 필요가 있었는지 의문이 들었다.

그래서 다음과 같이 다시 풀어보았다.

function solution(t, p) {
    let count = 0;
    
    for(let i = 0; i < t.length - p.length + 1; i++) {
        let str = t.slice(i, i + p.length);
        if(Number(str) <= Number(p)) count++;
    }
    
    return count;
}

코드도 간결해지고 실행 속도도 빨라졌다.

달라진 점은, 반복문 안에서 바로 조건을 비교하여 count를 한 점이다.

이렇게 한다면 또 배열을 순회할 필요도 없고 바로바로 count하며 더 효율적인 코드가 되었다!

function solution(s) {
    let count = 0;
    let zeroCount = 0;
    let arr = s.split('');
    let trans = '';
    let result = [];
    
    while(trans !== '1') {
        arr.forEach((el) => {
            if(el === '0') {
                zeroCount++;
            }
        })
        
        let filter = arr.filter(str => str !== '0');
        trans = filter.length.toString(2);
        count++;
        
        arr = trans.split('');
    }
    
    result.push(count, zeroCount);
    return result;
}

문제를 풀기 전 반복해야하는 순서를 정했다.

1. 0의 개수를 센다.

2. 0을 삭제한다.

3. 0을 삭제한 문자열의 길이를 2진수로 변환한다.

4. 변환한 횟수를 카운트한다.

5. s가 1인지 확인하고 아니면 다시 1번부터 반복한다.

이렇게 문제를 풀으려면 while문을 쓰는 것이 적합하다고 판단했다.

while문의 조건은 s가 1일 때까지 반복하도록 작성하고, forEach를 통해 0의 개수를 세어준다.

그 다음 filter 메서드를 활용하여 0을 제거한 배열을 반환해준다.

필터링한 배열의 길이를 통해 2진수 변환을 하고 trans에 저장해준다.

변환할 때마다 count를 더해주고, 여기서 주의할 점은 반복을 위해 trans를 다시 배열로 변환하여 arr에 저장해줘야한다.

그럼 s가 1이 될 때까지 해당 코드를 실행하고, 마지막에는 count(변환 횟수)와 zeorCount(0의 개수)를 리턴해주면 끝!

근데 보다보니 return 할 때 굳이 result를 선언하지 않아도 될 것 같다.

function solution(s) {
    let count = 0;
    let zeroCount = 0;
    let arr = s.split('');
    let trans = '';
    
    while(trans !== '1') {
        arr.forEach((el) => {
            if(el === '0') {
                zeroCount++;
            }
        })
        
        let filter = arr.filter(num => num !== '0');
        trans = filter.length.toString(2);
        count++;
        
        arr = trans.split('');
    }
    
    return [count, zeroCount];
}

function solution(arr) {
    let array = [...arr];
    let min = Math.min(...arr);
    
    if(array.length === 0) return [-1];
    
    for(let i = 0; i < array.length; i++) {
        if(array[i] === min) {
            array.splice(i, 1);
            return array;
        }
    }
}

정말 어이없는 문제였다 .. 분명 빈 배열과 10일 때 -1을 리턴하래서 그렇게 했었는데

알고보니 문제 오류였다 ㅎㅎ ;  그냥 빈 배열일 때만 -1을 리턴하면 된다.

이것 때문에 한참 시간을 버렸다 ㅎ;

일단 배열에서 최솟값을 찾아 저장해주고, 빈 배열을 먼저 확인하여 리턴해준다.

빈 배열이 아니라면 배열에서 최솟값과 같은 값을 찾고, splice 메서드를 통해 해당 인덱스를 삭제하고 리턴해주면 끝!

function solution(s) {
    let arrStr = s.split(' ');
     
    for(let i = 0; i < arrStr.length; i++) {
        arrStr[i] = arrStr[i].toLowerCase();
        arrStr[i] = arrStr[i].charAt(0).toUpperCase() + arrStr[i].slice(1);
    }
    
    return arrStr.join(' ');
}

일단 간편하게 수정하기 위해 공백을 기준으로 문자열을 배열로 변환해준다.

그런 후 반복문을 통해서 요구사항대로 수정해줄 예정이다.

제일 앞글자를 제외한 문자는 소문자이므로 먼저 소문자로 변환해준다.

그 후 문자열의 앞글자를 가져오는 charAt() 메서드를 이용해서 앞글자만 대문자로 변환해준다.

그리고 기존 앞글자는 삭제해준 뒤 둘이 붙여주면 된다.

마지막으로 join 메서드를 이용해서 문자열로 변환해주면 끝 !

처음에는 arrStr[i][0] = arrStr[i][0].toUpperCase();로 작성했었다. ㅎㅎ;

이게 안되는 이유가 문자열은 불변 객체이기 때문에 문자열의 특정 인덱스에 직접 값을 지정할 수 없다.

이제라도 알아서 다행이다 ㅎㅎ ..

function solution(A,B){
    let sum = 0;
    
    A.sort((a, b) => a - b);
    B.sort((a, b) => b - a);
    
    for(let i = 0; i < A.length; i++) {
        sum += A[i] * B[i];
    }
    
    return sum;
}

문제를 봤을 때, 최솟값을 구하려면 배열에서 가장 작은 수와 큰 수를 곱해주면 되지 않을까 하는 생각을 했다.

근데 그게 정답이었다 허허

일단 A, B를 각각 오름차순, 내림차순으로 정렬한 뒤 차례대로 곱해서 더해주면 끝!

근데 다른 사람 풀이를 보니, reduce를 활용하는걸 잊고 있었다.

reduce를 활용하면 가독성을 해치지 않는 선에서 더 간결한 코드 작성이 가능하다.

function solution(A,B){
    A.sort((a, b) => a - b);
    B.sort((a, b) => b - a);
   
    return A.reduce((total, val, i) => total + val * B[i], 0);
}