태야

<내 코드>

n = int(input())
stack = []
oper = []
cnt = 1
temp = ""
for i in range(n):
    num = int(input())

    while(cnt <= num):
        stack.append(cnt)
        oper.append("+")
        cnt += 1
    if(stack[-1] == num):
        stack.pop()
        oper.append("-")
    else:
        temp = False

if(temp == False):
    print("NO")
else:
    for i in oper:
        print(i)

처음에 무슨 문제인지 이해하는데 오래 걸렸다. 이 문제는 입력으로 주어진 수들의 수열을 push, pop으로 만들 수 있는지 확인하는 문제이다. 여기서 중요한 건 '스택 구조'이고 push를 오름차순으로 숫자가 들어간다는 것이다. 따라서 스택의 마지막 수가 비교하려는 입력의 수열의 수와 다르다면 해당 수열을 만들 수 없게 되는 코드다.

<내 코드>

import sys
n = int(sys.stdin.readline())
nums = []


def push(x):
    nums.append(x)


def pop():
    if(nums):
        return nums.pop()
    else:
        return -1


def size():
    return len(nums)


def empty():
    if(not nums):
        return 1
    else:
        return 0


def top():
    if(nums):
        return nums[-1]
    else:
        return -1


for i in range(n):
    inputOper = sys.stdin.readline().split()
    if (inputOper[0] == "push"):
        push(inputOper[1])
    elif(inputOper[0] == "pop"):
        print(pop())
    elif(inputOper[0] == "size"):
        print(size())
    elif(inputOper[0] == "empty"):
        print(empty())
    elif(inputOper[0] == "top"):
        print(top())

<내 코드>

n = int(input())
info = []

for i in range(n):
    age,name = input().split()
    age = int(age)
    info.append([age, name])

info.sort(key=lambda x: x[0])

for i in info:
    print(*i)

lambda 함수를 이용해서 age변수를 기준으로 오름차순으로 정렬하고, age 값이 같다면 인덱스(즉, 여기선 등록순) 순서로 정렬되게 된다. 그리고 출력을 할 때 언패킹을 통해 리스트 요소 값을 출력한다.

<내 코드>

n = int(input())
words = set()
for i in range(n):
    words.add(input())

sortWords = sorted(words, key=lambda x: (len(x), x))

for i in sortWords:
    print(i)

단어의 중복을 제거하기 위해 set() 집합을 사용했다. 입력값으로 들어오는 문자열들을 집합에 넣고, sorted 함수를 이용해 각 문자열을 1차로 길이에 따라 정렬하고, 길이가 같다면 2차로 사전의 오름차순으로 정렬하게 코드를 작성했다.

<내 코드>

n = int(input())
dots = []
for i in range(n):
    dots.append(list(map(int, input().split())))

dots = sorted(dots, key=lambda x: (x[1], x[0]))

for i in dots:
    print(*i)

<내 풀이>

- 1차 시도

n = int(input())
dots = []

for i in range(n):
    [x, y] = map(int, input().split())
    dots.append([x, y])

for j in range(0, n-1):
    curIdx = j
    for k in range(j+1, n):
        if(dots[curIdx][0] > dots[k][0]):
            curIdx = k
        if(dots[curIdx][1] > dots[k][1]):
            curIdx = k
    dots[j][0], dots[curIdx][0] = dots[curIdx][0], dots[j][0]
    dots[j][1], dots[curIdx][1] = dots[curIdx][1], dots[j][1]


for i in range(n):
    print(dots[i][0], dots[i][1])

: 시간 복잡도가 O(n^2)이라 안될 거 같았는데.. 역시나 시간 초과로 통과하지 못했다.

- 2차 시도

n = int(input())
dots = []

for i in range(n):
    dots.append(list(map(int, input().split())))

dots = sorted(dots, key=lambda x: (x[0], x[1]))

for i in dots:
    print(*i)

: 구글링을 통해 다른 사람들이 한 풀이를 참고했다. 일단 모르는 개념들이 많아서 이해하는데 어려움이 있었는데, 개념을 알고 나니 정말 간단하게 구현을 할 수 있다는 것을 알았다.

1) sorted(iterable, *, key=None, reverse=False)

: 첫 번째 인자로 정렬하고자 하는 반복 가능한 자료형을 넣는다. key인자의 값으로 함수를 넣어주면 함수의 반환 값을 기준으로 정렬을 해준다. 마지막 인자를 True로 하면 내림차순으로 정렬을 하게 된다.

2) lambda 함수

: 익명 함수를 만들 때 사용하며, 재사용이 되지 않는 간단하게 사용하는 함수이다. 함수명을 쓰지 않고 'lambda 인자 : 표현식' 형태로 사용하고 리턴 값을 보낸다.

3) Packing, Unpacking Operator *

<내 풀이>

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(), 화살표 함수 사용에 공부하게 됐다.