태야

<내 풀이>

function solution(clothes) {
    var answer = 1;
    var obj = {};
    
    for(var i=0; i < clothes.length; i++){
        if(obj[clothes[i][1]] >= 1){
            obj[clothes[i][1]] += 1; // 객체에 이미 같은 키값이 있다면 +1을 해준다.
        }else{
            obj[clothes[i][1]] = 1; // 새로운 종류의 옷(키값)이라면 1로 만든다.
        }
    }
    for (var key in obj){
        answer *= (obj[key]+1); // 각 옷 종류마다 안입는 경우를 포함
    }
    return answer - 1; // 전체 경우의 수에서 모두 안입는 경우 제외
}

이 문제에서 각 옷 종류마다 안 입는 경우가 있기에, +1씩 한 값들을 곱해주면 모든 경우의 수가 만들어진다.

여기서 answer-1을 하는 이유는 문제에서 옷을 무조건 하나는 입고 있다고 나오기 때문에, 모든 경우의 수에서 아무것도 입지 않는 경우의 수 1을 빼주는 것이다.

<다른 풀이>

function solution(clothes) {
    return Object.values(clothes.reduce((obj, t)=> {
        obj[t[1]] = obj[t[1]] ? obj[t[1]] + 1 : 1;
        return obj;
    } , {})).reduce((a,b)=> a*(b+1), 1)-1;    
} // reduce()의 초기값으로 빈 객체 {}를 설정해줌.

해석:

1. clothes.reduce(function,{}) 최초 값을 빈 객체로 생성하여 clothes를 순차적으로 키값(t [1]) 검색

2. undefined는 논리연산에서 false이므로 해당 키의 값이 undefined이면 해당 키값에 1을 넣어줌.

   키의 값이 존재한다면 해당 값에 +1을 해줌.

3. 이렇게 생성된 Key와 Value를 Object.values를 통해 값만 불러오도록 함.

4. reduce(function,1) 최초 값을 1로 설정하고 배열을 순차적으로 돌며 이전 값에 (해당 옷 종류의 개수)+1(옷을 입지 않은 경우)를 곱함.

5. 모든 옷을 입지 않은 경우 제외 -1 후 return.

reduce() 함수

사용법 : arr.reduce(callback[, initialValue])

reduce()는 빈 요소를 제외하고 배열 내에 존재하는 각 요소에 대해 callback 함수를 한 번씩 실행하는데, 콜백 함수는 다음의 네 인수를 받는다.

• accumulator

• currentValue

• currentIndex

• array

만약 reduce() 함수 호출에서 initialValue를 제공한 경우, accumulator는 initialValue와 같고 currentValue는 배열의 첫 번째 값과 같다. initialValue를 제공하지 않았다면, accumulator는 배열의 첫 번째 값과 같고 currentValue는 두 번째와 같다.

<출처>

<reduce 작동 방식 : 초기값을 설정 하지 않은 경우>

[0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array) {
	return accumulator + currentValue; 
});

// 화살표 함수로 표현
[0, 1, 2, 3, 4].reduce( (prev, curr) => prev + curr );

콜백은 4번 호출된다. 각 호출의 인수와 반환값은 다음과 같다.

reduce()가 반환하는 값으로는 마지막 콜백 호출의 반환 값(10)을 사용한다.

<reduce 작동 방식 : 초기값을 설정 해주는 경우>

[0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array) {
  return accumulator + currentValue;
}, 10);

reduce()가 결과로 반환하는 값은 20이다.

같은 배열에 대한 reduce() 사용이지만 초기값 설정 유무에 따라서 콜백 함수의 호출 수가 달라지고,

또 현재 값과 현재 값의 인덱스가 달라진다.

<내 풀이>

function solution(numbers) {
    
    var answer = numbers.sort((a,b) => (b.toString() + a.toString())-(a.toString() + b.toString())).join('');
    return answer[0] === '0' ? '0': answer;
}

reuturn 값으로 numbers 배열이 0으로만 구성되어 있을 경우 '0'만 출력한다. 여기서 answer[0]으로 준 이유는

값이 모두 '문자열'이기에 내가 원하는 '0'이 아닌 '0000'과 같은 경우가 나와 '0'으로 나오게 하고자 이런 방식을 취했다.

arr.sort([compareFunction])

: 인자로 정렬 순서를 정의하는 함수를 넣는다. 생략하면 배열은 각 요소의 문자열 변환에 따라 각 문자의 유니 코드 코드 포인트 값에 따라 정렬된다.

반환값으로 새로운 배열 값을 만드는 것이 아닌, 원 배열의 정렬된 배열 값이 나온다.

• compareFunction(a, b)이 0보다 작은 경우 a를 b보다 낮은 색인(인덱스)으로 정렬한다.. 즉, a가 먼저 온다.

• compareFunction(a, b)이 0을 반환하면 a와 b를 서로에 대해 변경하지 않고 모든 다른 요소에 대해 정렬한다.

• compareFunction(a, b)이 0보다 큰 경우, b를 a보다 낮은 인덱스로 정렬한다.

• compareFunction(a, b)은 요소 a와 b의 특정 쌍이 두 개의 인수로 주어질 때 항상 동일한 값을 반환해야 한다. 일치하지 않는 결과가 반환되면 정렬 순서는 정의되지 않는다.

<다른 풀이>

function solution(numbers) {
    
    var answer = numbers.map(c=> c + '').
    				sort((a,b) => (b+a) - (a+b)).join('');
    
    return answer[0]==='0'? '0' : answer;
}

numbers.map(c => c + ' ')

: 먼저 numbers 배열의 요소들을 문자열로 바꾼다. 여기서 map() 함수는 배열 내의 모든 요소 각각에 대하여 인자로 주어진 함수를 호출한 결과를 모아 새로운 배열을 반환해준다. 따라서 내 풀이에서 toString()을 일일이 해줄 필요가 없다.

<내 풀이>

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

    commands.forEach(function(element){
        
        var sliceArr = array.slice(element[0] - 1, element[1]);
        sliceArr.sort((a,b)=>{return a-b});
        
        answer.push(sliceArr[element[2] - 1]);

    });
    
    return answer;
}

forEach(callback함수) : 인자로 callback 함수를 넣는다. 인자로 주어진 함수를 배열 요소 각각에 대해 실행하고, undifined를 반환한다.

sort(compareFunction) : 인자로 정렬 순서를 정의하는 함수를 넣는다. 생략하면 배열은 각 요소의 문자열 변환에 따라 각 문자의 유니 코드 코드 포인트 값에 따라 정렬된다. 반환값으로 복사본이 만들어지는 것이 아닌, 원래 배열의 정렬된 배열이  반환값이다.

numbers.sort(function(a, b) {
  return a - b;
});
// 오름차순으로 정렬시킨다.

slice(begin, end) : 배열을 인덱스 begin 부터 end 앞까지 ,즉 인덱스 end-1까지 잘라낸다. 반환값으로 잘라내 추출한 배열을 반환한다.

<내 풀이>

function solution(heights) {
    var answer = []

    for(var i = heights.length - 1; i > 0; i--){
        for(var j = i - 1; j>=0; j--){
            if(heights[i] < heights[j]){
                answer.unshift(j+1);
                break;
            }else if(j === 0){
                answer.unshift(0);
            }
        }
        
    }
    answer.unshift(0); 
    return answer;
}

<다른 풀이>

function solution(heights) {
    return heights.map((v, i) => {
        while (i) {
            i--;
            if (heights[i] > v) {
                return i + 1;
            }
        }
        return 0;
    });
}

<공부>

map() : 인자로 주어진 함수(여기선 화살표 함수)에 모든 각각의 요소를 적용한 값으로 이루어진 배열을 반환합니다

Arrow function(화살표 함수) : 화살표 함수는 항상 익명이다. 메서드 함수가 아닌 곳에서 적합하며, 그래서 생성자로 사용을 못 한다.

var add = function (a,b) {
	return a+b;
};

// {} 블럭이 없는 경우(한 줄로 표현이 되는 경우)
var add = (a,b) => a+b;

// {} 블럭이 필요한 경우 --> 반드시 return 키워드를 사용해야함
var something = (a,b) => {
	//do something more
    return a * b;
};

<내 코드>

def solution(heights):
    answer = []
    re_ans = []
    re_heights = list(reversed(heights))
    pk = 0
    
    while(pk != len(heights)):
        tmp = re_heights[pk]
        if(pk == len(heights)-1):
            re_ans.append(0)
            break
        
        for i in range(pk + 1, len(heights)):
            if(tmp < re_heights[i]):
                re_ans.append(len(heights) - i)
                break
            else:
                if(i == len(heights)-1):
                    re_ans.append(0)
        pk += 1
        
    answer = list(reversed(re_ans))
    return answer

reverse() 함수는 단순히 해당 리스트의 값을 뒤집고, 어떤 값을 리턴하지 않는다.

reversed는 리스트의 함수가 아닌 파이썬 자체의 내장 함수로, 리턴으로 객체를 보내기에 리스트로 값을 얻기 위해 list() 함수를 사용했다.

<다른 풀이>

def solution(h):
    ans = [0] * len(h)
    for i in range(len(h)-1, 0, -1):
        for j in range(i-1, -1, -1):
            if h[i] < h[j]:
                ans[i] = j+1
                break
    return ans

진짜 이렇게 간단하게 해결을 할 수 있다니...정말..경이롭다...

여기서 range를 시작, 끝, 스텝을 이용해 -1씩 감소하게 해 reverse, reversed 없이 가능한 걸 알게 됐다.