y_flm's Blog

function solution(s) {
    return s.length % 2 ? 
        s[Math.floor(s.length / 2)] : 
        s[Math.floor(s.length / 2) - 1] + s[Math.floor(s.length / 2)];
}

먼저 짝수가 아니라면 문자열을 2로 나눠서 소수점은 버리고 그 인덱스에 해당하는 문자를 반환해주면 된다.

홀수라면 똑같이 일단 반으로 나누고 이전 인덱스와 해당 인덱스를 반환해주면 끝!

function solution(str_list) {
    let wordL = str_list.indexOf('l');
    let wordR = str_list.indexOf('r');

    if(wordL === -1 && wordR === -1) return [];
    
    if(wordL < wordR && wordL !== -1 || wordR === -1) {
        return str_list.slice(0, wordL);
    } else if(wordL > wordR && wordR !== -1 || wordL === -1) {
        return str_list.slice(wordR + 1);
    }
  }

처음에는 단순히 인덱스 번호로 큰지 작은지 비교한 후 slice하면 되겠지라는 생각으로 작성해보았다.

먼저 l과 r이 둘 다 없으면 indexOf에서 -1을 반환하므로 이를 확인하여 빈 배열을 반환해주도록 하고,

그게 아니라면 두 인덱스 번호를 비교해서 문제대로 배열을 잘라주었다.

근데 다른 사람 풀이를 보니 내가 굉장히 하드코딩을 했다는 생각이 들었다 ㅎㅎ;

function solution(str_list) {  
    for(let i = 0; i < str_list.length; i++) {
        if(str_list[i] === 'l') return str_list.slice(0, i);
        if(str_list[i] === 'r') return str_list.slice(i + 1);
    }
    
    return [];
}

이렇게 반복문을 사용하면 먼저 나오는 문자에 따라 slice가 실행되고,

반복을 다 해도 해당 문자가 없다면 반복문을 나가서 빈 배열을 리턴해주면 된다.

만약 배열의 길이가 길 경우에도 indexOf를 사용하면 배열을 2번 순회해야하기 때문에 비효율적이다.

for문은 한 번만 순회하면 되기 때문에 두번째 코드가 더 효율적이라고 할 수 있다.

function solution(arr) {
    arr.sort((a, b) => a - b);
    
    for(let i = 1; ; i++) {
        let check = true;
        
        for(let j = 0; j < arr.length - 1; j++) {
            if((arr[arr.length - 1] * i) % arr[j] !== 0) {
                check = false;
                break;
            }
        }
        
        if(check) {
            return arr[arr.length - 1] * i;
        }
    }
}

먼저 배열을 오름차순으로 정렬을 해주었다.

최소공배수를 구하기 위해서는 제일 큰 수를 기준으로 나머지 수들이 나누어떨어지는지 확인하는게 좋다고 생각했다.

그래서 마지막 수를 기준으로 만약 마지막 수 * 1과 나머지 수들이 모두 나누어 떨어진다면 그것이 최소공배수다.

모두 나누어떨어지는지 확인하기 위해서 check 변수를 선언하고, 하나라도 나누어 떨어지지 않는다면 check는 false가 되므로

마지막에 두번째 반복문을 나와서 check가 true일 경우에만 마지막 수 * 1을 반환하도록 설정해주었다.

function solution(people, limit) {
    let sortedPeople = people.sort((a, b) => a - b);
    let count = 0;
    
    for(let i = 0, j = sortedPeople.length - 1; i < j; j--) {
        if(sortedPeople[i] + sortedPeople[j] <= limit) {
            i++;
            count++;
        }
    }
    
    return sortedPeople.length - count;
}

먼저 몸무게가 적은 순으로 정렬해줬다.

for문을 이용해서 people 배열에서 i를 기준으로 점점 j가 줄어들면서 두 요소를 비교해준다.

만약 두 요소의 합이 limit보다 작거나 같다면 보트에 2명이 탈 수 있으니 count를 더해준다.

또한 다음 사람도 확인해야하기 때문에 i++ 도 해줘야한다.

마지막으로 전체 사람들의 수에서 count를 빼주면 된다.

count는 보트 수를 세는 것이 아닌 2명이 한 보트에 탔을 때를 세기 위함이다.

그렇기 때문에 전체 수에서 2명이 한 보트에 탔을 경우를 빼주면 전체 보트 수가 나온다.

처음에는 그냥 2중 반복문으로 작성했었는데 다른 사람 풀이보고 변수를 2개 선언할 수 있다는 것을 알게되어 수정해보았다 ㅎㅎ ;

function solution(n, lost, reserve) {
    let lostStudents = lost.filter(student => !reserve.includes(student)).sort((a, b) => a - b);
    let reserveStudents = reserve.filter(student => !lost.includes(student)).sort((a, b) => a - b); 

    for (let i = 0; i < reserveStudents.length; i++) {
        for (let j = 0; j < lostStudents.length; j++) {
            if (Math.abs(reserveStudents[i] - lostStudents[j]) === 1) {
                lostStudents[j] = null;
                break;
            }
        }
    }

    return n - lostStudents.filter(student => student !== null).length;
}

먼저 제한 사항을 보면, 여벌 체육복이 있는 학생도 잃어버렸을 수 있다고 하니까

lost와 reserve 배열에 같은 학생이 있다면 제외시켜준다.

또한 순서가 섞여있다면 오류가 발생할 수 있으므로 정렬도 해줘야한다.

그 다음은 간단하게 reserve 배열을 기준으로 lost 배열을 순회한다.

절댓값 메서드인 Math.abs를 사용하여 reserve - lost가 1이면 앞이나 뒤에 있는 것이므로 빌려줘도 된다는 뜻이다.

따라서 해당 lost 자리에는 null을 넣어주고 break를 통해 다음으로 넘어간다.

마지막으로 전체 학생 수에서 lost 배열 중 null이 아닌 학생 수를 빼주면 된다. 

function solution(rank, attendance) {
   let list = [];
    
    for (let i = 0; i < attendance.length; i++) {
        if (attendance[i] === true) {
            list.push(i);
        }
    }
    
    list.sort((a, b) => rank[a] - rank[b]);

    return 10000 * list[0] + 100 * list[1] + list[2];
}

먼저 false인 선수는 제외시키고 참여가 가능한 선수들의 인덱스만 list에 넣어준다.

그 후 등수가 높은 선수대로 정렬시켜야하는데, list는 현재 인덱스 번호들이 들어있으므로

순위별 정렬을 위해 rank[a] - rank[b] 기준으로 정렬시켜주면 된다.

그 다음은 문제대로 순위가 높은 선수들의 번호로 계산해주면 끝!

function solution(date1, date2) {
    return (new Date(date1) < new Date(date2)) ? 1 : 0;
}

날짜 관련 문제를 안풀어본 것 같아서 한 번 풀어봤다.

처음에는 new Date(date1[0], date1[1], ..) 이런 식으로 썼었는데 알고보니 배열 형식 그대로 넣어도 됐었다 ㅎㅎ;

엄청 간단한 문제였다.

function solution(arr, query) {
    let result = [...arr];
    
    for(let i = 0; i < query.length; i++) {
       if(i % 2 === 0) {
           result = result.slice(0, query[i] + 1);
       } else {
           result = result.slice(query[i]);
       }
   }
    
    return result;
}

이 문제는 문제를 이해하는데 시간을 더 썼다;; ㅎㅎ 

문제를 이해해보면, query의 인덱스가 짝수인지 홀수인지에 따라 작업이 달라진다.

만약 query의 인덱스가 짝수라면, arr에서 query[i] 값의 인덱스 뒷부분을 잘라내야한다.

한마디로 arr[query[i]]의 뒷부분을 잘라내는 것이다.

홀수도 마찬가지로 arr[query[i]]의 앞부분을 잘라내는 것이다.

문제를 이해하면 풀이는 쉽다.

일단 query 인덱스의 짝수 홀수 여부를 가리고, slice를 이용해서 arr 값을 추출해줬다.

짝수일 경우에는 arr에서 query[i] 값의 인덱스 뒷부분을 잘라내야하므로 처음 인덱스부터 query[i] + 1까지 추출해준다.

홀수일 경우에는 앞부분을 잘라내는 것이므로 query[i] 인덱스 이전 값들은 제외시켜주면 된다.