태야

<내 코드>

- Java

import java.util.*;

class Solution {
    public int[] solution(int[] progresses, int[] speeds) {
        
        List<Integer> temp = new ArrayList<>();
        List<Integer> result = new ArrayList<>();
        
        for(int i=0; i < progresses.length; i++){
            if((100-progresses[i]) % speeds[i] == 0){
                temp.add((100-progresses[i]) / speeds[i]);
            }else{
                temp.add(((100-progresses[i]) / speeds[i]) + 1);
            }
        }
        
        // 리스트 temp를 비교해 배포마다 몇 개씩 되는지 
        int cnt = 1;
        int ck = temp.get(0);
        for(int j=1; j < temp.size(); j++){
            if(ck >= temp.get(j)){
                cnt += 1;
            }else{
                result.add(cnt);
                ck = temp.get(j);
                cnt = 1;
            }
            
            if(j == (temp.size()-1)){
                result.add(cnt);
            }
        }
        
        // 리스트를 배열로 바꿔 출력
        int[] answer = new int[result.size()];
        for(int i=0; i<result.size(); i++){
            answer[i] = result.get(i);
        }

        return answer;
    }
}

- Python

def solution(progresses, speeds):
    answer = []
    temp = []

    for i in range(len(progresses)):
        days = (100 - progresses[i]) % speeds[i]
        if (days) == 0:
            temp.append((100 - progresses[i]) // speeds[i])
        else:
            temp.append((100 - progresses[i]) // speeds[i] + 1)

    ck = temp[0]
    cnt = 1
    for i in range(1, len(temp)):
        if ck >= temp[i]:
            cnt += 1
        else:
            ck = temp[i]
            answer.append(cnt)
            cnt = 1
            
        if i == (len(temp)-1):
            answer.append(cnt)

    return answer

<내 코드>

class Solution {
    public int[] solution(int[] prices) {
        int[] answer = new int[prices.length];
        
        for(int i=0; i<prices.length; i++){
            for(int j=i+1; j< prices.length; j++){
                if (prices[i] > prices[j]) {
                    answer[i] = j-i;
                    break;
                }
                if(j == prices.length-1){ // 마지막 요소 확인
                    answer[i] = j-i;
                }
            }
        } 
        return answer;
    }
}

def solution(prices):
    answer = []
    
    n = len(prices)
    for i in range(n): #0~4
        cnt = 0
        if i == n-1:
            answer.append(cnt)
            break
        for j in range(i+1,n): #1~4
            if prices[i] <= prices[j]:
                cnt += 1
            else:
                cnt += 1
                break
        answer.append(cnt)
    
    return answer

<내 코드>

def solution(s):
    answer = []
    s = list(eval(s[1:-1])) #문자열을 리스트로 변경
    
    if len(s) == 1:
        answer.append(s[0])
        
    else:
        temp = sorted(s, key=lambda x: len(x)) # 원소 개수별로 정렬
        temp = [list(i) for i in temp]  # 내부 집합 자료형을 리스트로 변경

        for item in temp:
            for j in range(len(item)):
                if item[j] not in answer:
                    answer.append(item[j])
                else:
                    continue
    return answer

<내 코드>

def solution(board, moves):
    answer = 0
    basket = []
    cnt = 0
    
    for i in moves: # 열
        for j in range(len(board)):  # 행
            dall = board[j][i-1]
            
            if dall == 0:
                continue
            if dall != 0 and len(basket) == 0:
                board[j][i-1] = 0
                basket.append(dall)
                break
                
            elif dall != 0 and len(basket) != 0:
                board[j][i-1] = 0
                # 연속으로 같은 값인지 판단
                if basket[-1] == dall:
                    cnt += 2
                    basket.pop()
                else:
                    basket.append(dall)
                break

    answer = cnt                   
    return answer

스택을 이용해 현재 인형과 스택의 마지막 요소와 같은지 판단한다.

같으면 인형 2개가 터트려지고 카운트를 2올린다. 다르면 그대로 스택에 추가한다.

<다른 사람 코드>

def calc(priority, n, expression):
    if n == 2:  # 마지막 연산까지 마친 경우
        return str(eval(expression))
    if priority[n] == '*':
        res = eval('*'.join([calc(priority, n+1, e)
                             for e in expression.split('*')]))
    if priority[n] == '+':
        res = eval('+'.join([calc(priority, n+1, e)
                             for e in expression.split('+')]))
    if priority[n] == '-':
        res = eval('-'.join([calc(priority, n+1, e)
                             for e in expression.split('-')]))
    return str(res)


def solution(expression):
    answer = 0
    priorities = [
        ('*', '-', '+'),
        ('*', '+', '-'),
        ('+', '*', '-'),
        ('+', '-', '*'),
        ('-', '*', '+'),
        ('-', '+', '*')
    ]
    for priority in priorities:
        res = int(calc(priority, 0, expression))
        answer = max(answer, abs(res))

    return answer

eval(), join() 함수를 이용해 재귀 호출로 문제를 풀었다.

eval(문자열) : 문자열로 표현된 파이썬 식을 인수로 받아 결괏값을 주는 함수다.

' ? '.join(list) : 리스트에 특정 구분자를 포함해 문자열로 변환해준다.

문제의 접근법은 다음과 같다. 우선순위가 - >+ >* 라고 가정했을 때* 연산을 하기 위해서는 + 연산의 결괏값이 먼저 필요하다고 생각할 수 있다. 동일하게 + 연산을 하기 위해서는 - 연산의 결과값이 먼저 필요하다.

이런 이유로 인해 먼저 * 을 기준으로 수식을 쪼갠다. * 연산자는 우선순위가 가장 낮기 때문에 - , + 를 먼저 계산한 결괏값들을 가지고 마지막에 계산한다. 쪼개진 수식은 다시 같은 이유로 그다음 낮은 우선순위를 가지는 + 로 쪼갠다.

+ , * 로 쪼개진 수식들은 최종적으로 - 연산만 가진 수식이 되거나 그냥 숫자만 있는 수식이 되는데 이때 수식을 계산하고 값을 리턴한다. (그냥 숫자만 있는 수식은 그대로 리턴한다)

<내 풀이>

function solution(bridge_length, weight, truck_weights) {
   var answer = 0;
   var queue = []; // 현재 다리 위 트럭 상태
   var que_weight = 0; // 현재 다리 위 무게

   while (truck_weights.length != 0) {
      answer += 1;

      if (queue.length === bridge_length) { // 다리 길이 만큼 요소가 찼다면, 마지막 요소 빼냄 
         que_weight -= queue.pop();
      }

      if (que_weight + truck_weights[0] <= weight) { // 다리 무게가 여유 있을 때
         var next_tk = truck_weights.shift();
         queue.unshift(next_tk); //앞쪽 트럭을 다리에 올림
         que_weight += next_tk; // 다리 위 트럭 무게 더해줌 
      } else {
         queue.unshift(0); // 무게 여유가 없다면 0을 채워 넣음.   
      }

      if (truck_weights.length === 0) { // 마지막 트럭이 들어갔을 때
         answer += bridge_length;      // 초를 다리 길이만큼 더해주고 종료!   
         break;
      }
   }
   return answer;
}

arr.shift()

배열에서 첫 번째 요소를 제거하고, 제거된 요소를 반환한다. 빈 배열의 경우 undefined를 반환한다.

arr.unshift()

새로운 요소를 배열의 맨 앞쪽에 추가하고, 새로운 길이를 반환한다.

반환 값으로는 새 요소가 추가된 배열의 길이 값을 반환한다.

<내 풀이>

function solution(answers) {
    var answer = [];
    var one = [1,2,3,4,5];
    var two = [2,1,2,3,2,4,2,5];
    var three = [3,3,1,1,2,2,4,4,5,5];
    var cnt = [0,0,0];
    
    for(var i=0; i < answers.length; i++){
        if(one[i % one.length] === answers[i]){
            cnt[0] += 1;
        }
        if(two[i % two.length] === answers[i]){
            cnt[1] += 1;
        }
        if(three[i % three.length] === answers[i]){
            cnt[2] += 1;
        }
    }
    
    cnt.forEach((element, idx) =>{
        if(element === Math.max(...cnt)){
            answer.push(idx + 1);
        } 
    });
 
    return answer;
}

1. answers배열 요소만큼 반복할 동안, one, two, three 배열 요소들을 반복적으로 돌면서 answers 요소와 비교한다.

2. 요소가 같다면 카운팅을 1씩 증가한다.

3. forEach를 통해 배열 요소별로 콜백 함수를 실행한다.

4. cnt배열에서 최대값인지 판단해, 맞다면 answer 배열에 푸시한다.

<다른 풀이>

function solution(answers) {
    var answer = [];
    var a1 = [1, 2, 3, 4, 5];
    var a2 = [2, 1, 2, 3, 2, 4, 2, 5]
    var a3 = [ 3, 3, 1, 1, 2, 2, 4, 4, 5, 5];

    var a1c = answers.filter((a,i)=> a === a1[i%a1.length]).length;
    var a2c = answers.filter((a,i)=> a === a2[i%a2.length]).length;
    var a3c = answers.filter((a,i)=> a === a3[i%a3.length]).length;
    var max = Math.max(a1c,a2c,a3c);

    if (a1c === max) {answer.push(1)};
    if (a2c === max) {answer.push(2)};
    if (a3c === max) {answer.push(3)};


    return answer;
}

array.filter(callbackFunc(처리할 현재 요소, [처리할 현재 요소의 인덱스], [filter를 호출한 배열]))

: 주어진 함수의 테스트를 통과하는 모든 요소를 모아 새로운 배열로 반환한다.

인자로 들어간 콜백함수는 true를 반환하면 요소를 유지하고, false를 반환하면 버린다.

분석

1. filter(a, i) 인자로 처리할 요소와 해당 요소 인덱스를 담을 인자를 넣었다.

2. 현재 처리할 요소와 a1, a2, a3 배열의 각 요소가 같다면, 요소(a)를 유지하고 아니면 버린다.

3. 필터링 된 요소들의 수를 각각 a1c, a2c, a3c에 담는다.

4. Math.max()를 이용해 최댓값을 구한다.

5. 각 최대값인지 따져서 answer배열에 푸시한다. 여기서 전부 다 최댓값으로 같다면 오름차순으로 정렬해야 하기에 if문을 1부터 3까지 차례대로 실행되게 해 따로 정렬할 필요를 줄였다.

이 문제를 통해 filter함수, Math.max(), 화살표 함수 사용에 공부하게 됐다.

<내 풀이>

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() 사용이지만 초기값 설정 유무에 따라서 콜백 함수의 호출 수가 달라지고,

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