시간이 많이 지났지만, 대학원 입시와 관련한 정보들을 기록해보려고 끄적여본다 ㅎㅎ 대학원을 준비해 본 사람이라면, 특히 내가 원하는 학과에대한 정보를 찾아내기란 하늘의 별따기라는 것을 알 것이다 (물론, 타대학원이라면 더더욱 ,,,) 나도 타대학원을 지원하는 과정에서 서칭의 한계를 느껴서 내가 하나 남겨두면 누군가에게 도움이 되지않을까 하여 작성하기로 해따!!!!!

티스토리로 이사하였어요:-) 티스토리 링크

📋 스펙

부끄럽지만,,, 나의 스펙을 적어보겠다..

• 학부: 서성한 라인의 컴퓨터학과

• 학점: 3점 후반
• 프로젝트 경험: 요즘에는 너무 멋진 사람들이 많아서 딱 중간.. 정도?
• 수상 경험: 제4회 AIXBookathon 장려상 → 링크
• 그 외 경험: 네이버 인턴(2개월), 학부연구생(2개월)

운이 좋아서 네이버라는 좋은 곳에서 인턴을 하긴 했지만, 학부연구생 당시 인공지능 관련 논문만 읽었기 떄문에 학술적인 경험이 부족하다는 생각을 했었다.

🗂️ 원서 전형

연세대학교는 진학사 같은 사이트에서 접수를 진행하지 않고 아래 링크에서 원서 접수를 진행한다.

🦅 https://gradnet.co.kr/yonsei/

위 사이트에서 학업 및 연구 계획서를 제출하게 된다. 형식은 정해진게 없었다. 나는 자기소개 및 진학동기 파트와 연구 계획 파트로 나누어서 작성을 진행했다. 그외 대학 졸업/성적 증명서, 인턴 경험이 있다면 인턴 근무 확인서, 수상 증명 등등 나를 보여줄 수 있는 자료들을 (특히, 내가 자기소개에 작성한 경우) 제출하였다! 아! 영어 성적의 경우 학과별로 반영 방법이 다른 것으로 알고 있는데, 컴퓨터과학과는 필수는 아니고 제출하면 참고하겠다. 정도의 뜻을 내포하고 있긴 한다. 하지만,, 뭐든 있다면 제출하는게 좋고 제출한다면 높은 점수가 좋을 것이다 ^^ .. 나는 다른 대학교의 대학원에서 영어 성적 제출이 필수여서 토플을 봐두었기 때문에 그 점수를 제출하였다! 이 정도하면 원서 전형은 끝이 난다:)

👼🏻 구술 전형

원서접수가 10월 30일까지 마감이었고 구술 시험 대상자는 11월 24일 오후 5시에 발표가 났다. 왜이렇게 학교들은 발표할 떄 5시를 좋아할까? ,, ㅎ 아무튼, 조기 발표 이런 것은 없었고 거의 정각에 발표가 났던 것 같다. 결과는 [최종합격], [구술시험대상자], [불합격]으로 구분된다. 만약 누군가 원서를 넣고 바로 최종합격이 된다면 너무 축하하고 질투난다!! 그러면 바로 그냥 합격이다. 나는 구술 시험 대상자로 구분 되었고, 12월 2일에 몇 시에 구술 면접을 진행할 것이라는 이메일을 받게 되었다. 대학원 구술 면접은 처음이라 긴장이 많이 되었는데, 이때 정말 정보 찾기도 너무 어려워서 마음 고생했던 기억이 난다 하하!! 그래서 내가 어떻게 준비를 했고 컴퓨터학과 지원자들을 위한 꿀팁을 개봉박두 해보겠다 ㅋㅎ

우선, 면접의 형태는 교수님 3분 구술 대상자 3명 이렇게 다대다 면접으로 진행된다. 아무튼 ... 꿀팁아닌 꿀팁이 제일 먼저 궁금할테니.. 먼저 작성해보겠다.

💡 구술 전형 꿀팁

1. 면접은 3:3으로 진행된다. 다른 지원자의 대답을 경청하자. 교수님께서 방금 ~~ 학생이 한 답변이 맞다고 생각하나요? 만약 아니라면 그 이유는 뭔지 말해보겠어요? 라는 식의 질문이 나온다.
   
2. 질문을 듣고 가장 먼저 대답해야한다는 부담감은 내려놓자. 앞에서 말했듯 다대다 면접인데, 누군가를 지목해서 답변을 하라고 하시지 않는다. 내가 먼저 해야지 하다가 실수 할 수 있다. 상대방의 대답을 듣다보면, 질문의 내용을 다시 한 번 캐치하고 정리할 시간이 주어진다.
   3, 이건 모든 면접에서 해당하는 것이지만, 모든 것을 다 아는 척하지 말자. 우리는 엄연히 학부밖에 졸업하지 않은 학생들이다. 그리고 평가하시는 분들은 우리보다 더 많은 지식을 갖고 공부를 하신 교수님들이다. (다른 회사 면접도 마찬가지) 모른다면, 솔직하게 내가 아는만큼을 말하고 더 깊이있는 내용은 추가적으로 공부하겠다는 뉘앙스로 넘기자.
   

꿀팁은 이정도이다. 대단한 것은 없고.. 그냥 한 번 머릿속으로 인징하고 가면 좋을..(?) 내용들이라 정리해보았다!! 본격적으로 어떤 내용들을 준비했는지 정리해보겠다. 컴퓨터과학과는 전공 면접을 보는 것 같았는데, 크게 2가지 영역으로 나누어 준비했다.

1) 내 경험 및 제출한 서류에 적은 내용들을 공부했다. 이건 어느 면접을 가도 당연히 준비해가야 하는 부분이다. 내가 이 프로젝트에서 왜 이 기술을 썼고, 아쉬운 점이 뭐였는지 그리고 프로젝트 당시에는 이게 젤 편하니까~ 라면서 아무생각 없이 진행했더라도 명확한 이유를 찾아야한다. 또한, 나는 인턴 경험이 있기 때문에 왜 취업이 아닌 대학원을 지원하게 되었는지 나만의 스토리 텔링도 준비했다. 충분히 날카로운 질문이 나올수도 있다고 생각했음

2) 전공 공부를 했다. 여기저기 정보들을 취합해보니 연세대학교 컴퓨터과학과는 면접에서 전공을 질문하는 것 같았다. 그래서 알고리즘/운영체제/데이터베이스 파트로 나누어 공부했다! 정보가 많지는 않았지만, 찾아본 결과 알고리즘/운영체제를 위주로 질문하시는 것 같았다. 따라서, 알고리즘 4 운영체제 4 데이터베이스 2 정도 비율로 시간을 투자해서 공부했다. ( 아! 그리고 중간에 가능하면 전공이나 이런 면접 경험이 많은 친구에게 모의 면접을 부탁하자! 나의 경우 남자친구가 도와줬는데 회사 면접과 대학원 면접은 분명 차이는 있지만, 긴장하고 온라인으로라도 면접을 보고 정곡을 찔려보고 아니고의 차이는 확연히 다르다!! 이 경험으로 내가 부족한 부분들을 추가적으로 공부할 수 있으니 적.극.추.천 )

그리고 실제 구술 시험장은 어땟는지... 이야기해보겠다 실은 나는 이 당시 지독한 감기에 걸렸다.. 하하 😢 면접 3일 전에는 링겔을 맞았고 그 다음날에 괜찮다 싶더니 새벽에 열이 펄펄 끓어서 잠도 제대로 못 잤다. 공부를 하고 싶어도 못하는 상황이 너무 억울하고 화가 나서 심적으로 무너졌던 것 같다. 결국 면접 전 날까지 주사를 맞아서 겨우 열을 내리고 면접장에 도착했다. ( 독감 검사, 코로나 검사를 모두 진행해서 다른 분들에게 피해가 안가도록 비대면 면접을 진행하려고 했는데 둘다 음성 뜸.. ㅋ ,,,, 마스크 쓰고 대기하고 면접 볼때만 벗었다) 대기 시간을 그리 길진 않았고, 내가 거의 마지막 타임이라서 교수님들께서 10분 정도 휴식하고 진행하셨다. 목소리가 잘 안나와서 생강차를 계속 마시면서 대기 했음 ㅎㅎ... 아무튼, 그렇게 3명이 호명되고 면접장 앞에 대기하고 들어간다!! 세명이서 차례로 자기소개를 하고 면접은 진행된다!! 면접이라 당연히 긴장은 되었고 다대다 면접이 처음이다 보니 더더욱 긴장했다. 누군가를 지목하지 않고, 먼저 대답하는 사람이 임자.. ㅎ 하지만, 위 꿀팀에서 소개했듯 그게 끝이 아니다. 먼저 질문에 대답한 사람의 답변에 동의하는지 비동의하는지 말할 기회가 주어진다. 이 기회를 잘 활용하도록 !! ㅎㅎ 그리고 1번 사항에 준비한 내 경험들 혹은 연구 계획서 관련한 질문은 하지 않았당 그래서 오히려 자기소개할 때 본인을 어필하기 위해 경험들을 간략하게 설명하는 편이 좋을 듯 싶다 ! 전공 질문은 총 2개로 예상대로 알고리즘/운영체제에서 나왔다 😎 질문은 면접 끝나자마자 어딘가에 메모해두었는데, 어디있는지 기억이 안난다 ,, 혹시 궁금하시면 댓글... 남겨주시면 그때 부랴부랴 찾아보겠다 ^ . ^

📫 컨택 및 연구실 면접

실은 연세대학교에는 컴퓨터과학과 와 인공지능학과 가 있다. 내가 인공지능이 아닌 컴퓨터과학과를 선택한 이유는 컨택을 미리 진행하지 않고 최종합격을 하게되면, 컨택 일정이 주어지는 시스템 때문이다. 컨택과 관련해서 자대에서 너무 마음이 아팠기 때무네... ㅎㅅㅎ 뒤도 돌아보지 않고 컴퓨터과학과를 선택했다! 실은 서류 접수 전에 타대학원이라면 원하는 연구를 하시는 교수님을 살펴보는 일이 매우 중요하다!! 나는 들어가고 싶은 연구실이 딱 하나 있었고 컴퓨터과학과 컨택 기간이 시작되자마자 교수님께 메일을 드렸다! 그리고 일정을 잡고 면접을 보고 최종 합격을 받고 지금 잘 다니고 있다!!! 연구실을 말하긴 내가 너무 특정될까 부끄러우니 숨길 것이다!! 벨로그에 비밀 댓글이 있다면 몰래 알려드릴 수도 있는데 없는 것 같으니까(?) 비밀이다!!! 우리 연구실 사람들도 너무 따뜻하고 멍청한 나의 질문에 모두들 도와주려고 나서주고 .. 쏘 스윗이다 ㅎㅎ

아무튼 이 글을 보는 모두 원하는 대학원에 합격하고 원하는 연구실에 들어가 행복한 연구생활을 하길 바란다 🩵

문제 요약

단순하게 BFS를 활용해서 기준이 되는 "1" 노드와의 거리가 가장 먼 노드의 개수를 구한다.

문제 풀이

from collections import deque 

def solution(n, edge):
    answer = 0

    # 간선과 노드 정보 graph에 저장 
    graph= [[] for _ in range(n+1)]

    for e in edge:
        n1, n2 = e[0], e[1]
        graph[n1].append(n2)
        graph[n2].append(n1)
    #print(graph)

    # BFS 로직
    queue = deque([1])
    distance = [-1]*(n+1)
    distance[1] = 0 #출발 시작 노드 0 

    while queue:
        curr_node = queue.popleft()
        connect_edge = graph[curr_node]
        #print(connect_edge)
        for e in connect_edge:
            #print(f"{e} 입니다.")
            if distance[e] == -1: #방문한 적 없는 경우
                queue.append(e)
                distance[e] = distance[curr_node] + 1

    #print(distance) // [-1, 0, 1, 1, 2, 2, 2]

    max_dist = max(distance)

    for i in distance:
        if i == max_dist:
            answer +=1

    return answer

📌 느낀 점

• 삼성식 BFS/DFS 에 익숙해져 있는데 이렇게 간선/노드의 정보를 활용하는 문제에 익숙해지기 괜찮은 문제이다.

문제 요약

문제에서의 조건은 다음과 같다.
1 ) 모든 차량이 고속도로를 이용하면, 카메라를 무조건 한 번은 만나도록 설치하는 것이 목표
2 ) 최소 몇 대의 카메라를 설치해야하는지!

처음에는 단순하게 수직선으로 그려서 생각해보았는데, 구간이 겹치는 부분은 cctv가 중복되어서 설치될 필요가 없고, 겹치지 않는 부분 (즉, 허점이 될 수 있는 곳)에 cctv를 설치해주어야한다. 따라서, 차량이 나가는 시점을 기준으로 오름차순 정렬을 진행해주고 단순하게 앞의 차량이 나간 시점과 그 다음 차량의 진입 시점이 겹치는 지 여부를 판단해주면 되는 문제이다.

문제 풀이

def solution(routes):
    cctv = 1
    # Routes : 차량 진입, 차량 나간 시점
    routes.sort(key = lambda x:x[1]) # 나간시점을 기준으로 정렬 

    _in, _out = routes[0][0], routes[0][1]

    for i in range(1, len(routes)):
        s, e = routes[i][0], routes[i][1]
        #print(s, e, _out)
        if s > _out:
            # 하나 뒤 진입 지점이 앞 차의 나가는 시점보다 크면, 공백이 생기니까 cctv 추가
            cctv+=1
            #print(cctv)
            _out = e



    return cctv

📌 느낀 점

• 한 번 로직을 생각하면 정말 금방 구현이 되는 문제이지만, 빠르게 생각해내기 조금 힘들었던 것 같다.

문제 요약

문제에서의 조건은 다음과 같다.
1 ) 제공되는 모든 항공원을 사용해야한다.
2 ) 만약 가능한 경로가 2개 이상이라면, 알파벳 순서가 앞서는 경로를 return
3 ) 모든 도시를 방문할 수 없는 경우는 주어지지 않는다.

문제를 파악해보면 모든 경로를 파악하고 가능한 경로를 구해야하기 때문에 DFS 알고리즘을 사용하기로 결정했다. 하지만, 어떤 방식으로 구현해야할지 첫 틀을 잡는데 시간을 소요했던 것 같다.

문제 풀이

def solution(tickets):
    answer = []
    isTicket = [0]*len(tickets) # ticket 사용 여부

    def DFS(airport, path):
        if len(path) == len(tickets)+1:
            answer.append(path)
            return

        for idx, ticket in enumerate(tickets):

            if airport == ticket[0] and not isTicket[idx]:
                isTicket[idx] = 1 # 티켓 사용
                #print(path+[ticket[1]])
                # path + [ticket[1]] 방식: path 리스트에 ticket[1]을 추가한 새로운 리스트 반환
                # -> 재귀 함수에서 유용 
                # path.append(ticket[1]) 방식 : 리스트 자체를 수정 
                DFS(ticket[1], path+[ticket[1]])
                isTicket[idx] = 0


    DFS("ICN", ["ICN"])
    answer.sort()
    #print(answer)

    return answer[0]

📌 해결 방법

• BFS/DFS 문제에 해당하고 그 중 DFS를 활용하였다.

문제 요약

문제에서의 가장 큰 목표는 2가지이고 순서대로 우선순위를 가지고 있다. 1 ) 이모티콘 플러스 서비스 가입자 최대 2 ) 이모티콘 판매액을 최대로

• 할인율은 [10, 20, 30, 40] 중 하나로 결정된다.
• 사용자들은 각자의 기준을 바탕으로 이모티콘을 구매하거나 이모티콘 플러스에 가입한다.
  • 일정 비율 이상의 할인율은 모두 구매한다.
  • 이모티콘 구매 비용의 합을 구했을 때 일정 가격이 넘어가면 구매했던 이모티콘을 모두 취소하고 이모티콘 플러스에 가입한다.

처음에 문제를 해결할 떄 바로 해결책이 생각나지 않아서 조금 헤맸었다. 무작정 그리디를 생각했지만, 마땅한 그리디 식 규칙성(?)이 보이지 않았다. 그래서 설마 전부 다 탐색해야하나 생각을 했었는데, 이모티콘 개수를 확인하고 완전 탐색 유형인가보다 하고 감을 잡았던 것 같다.

아래 해설 내용이 헷갈리면 주석 처리해둔 부분을 풀고 돌려보면 감이 잡힐 것이다!

문제 풀이

def solution(users, emoticons):
    answer = [0, 0]

    discount = [10, 20, 30, 40] # 할인율 
    emo_discount = []   

    # DFS 를 활용해서 모든 경우의 할인율 조합 구하기 
    def DFS(arr, d):
        # arr는 이모티콘 별 할인율 조합
        if d == len(arr):
            emo_discount.append(arr[:]) # 얕은 복사 
            return
        else:
            for i in discount: # 할인율 for문 돌면서 재귀적으로 함수 호출
                arr[d] +=i
                #print(arr)
                DFS(arr, d+1)
                arr[d] = 0 # DFS 다 돌고나서 배열 원상 복구
                # print(arr)
    DFS([0]*len(emoticons), 0)

    #print(emo_discount)
    # 완전 탐색
    for d in emo_discount:
        regs = 0 # 가입자
        prof = 0 # 수익         

        for user in users:
            paid = 0 
            for i in range(len(d)):
                if user[0] <= d[i]: # 일정 할인율 이상이라면
                    paid += emoticons[i] * (100-d[i]) / 100
            if user[1] <= paid: # 일정 가격 이상이라면 
                paid = 0
                regs += 1
            prof += int(paid)

        #print(regs, prof)


        # 정답 결정 우선순위: 가입 여부 -> 버는 돈 
        if answer[0] <= regs:

            if answer[0] == regs:
                answer[1] = max(prof, answer[1])
            else:
                answer[0] = regs
                answer[1] = prof


    return answer

📌 해결 방법

• 완전탐색 문제에 해당한다.
• 완전 탐색을 위해서 할인율은 4가지로 정해져 있고, 이모티콘은 최대 7개이므로 모든 조합을 DFS 를 활용해서 정리해준다.

문제 요약

그리디 문제에 해당한다. 문제를 이해해보면, 박스를 배달하거나 수거한 부분에 대해서 리스트를 업데이트 해줄 필요는 없다. (처음에 이런 식으로 풀이했다가 시간 초과가 발생했다 .. ^^) 즉, 간단하게 가장 먼 거리에서부터 고려하는 과정으로 문제를 해결해나갈 수 있다!

아래 해설 내용이 헷갈리면 주석 처리해둔 부분을 풀고 돌려보면 감이 잡힐 것이다!

문제 풀이

# cap : 한 번에 들고 갈 수 있는 택배 상자
# n : 집의 개수 

def solution(cap, n, deliveries, pickups):
    answer = 0

    deliver = 0
    pickup = 0

    for i in range(n-1, -1, -1):
        deliver += deliveries[i]
        pickup += pickups[i]
        #print(f"index : {i}, deliver: {deliver}, pickup: {pickup}")

        # 배달 해주거나 / 수거 해주기
        while deliver > 0 or pickup > 0:
            deliver -=cap
            pickup -= cap
            #print(deliver, pickup, i)
            answer += (i+1)*2
            #print(answer)


    return answer

📌 해결 방법

• deliver와 pickup 변수는 가장 먼 거리에 해당하는 값을 더한 것이다.
• while 문을 활용해서 cap (한 번의 움직임으로 가져가거나 가져올 수 있는 박스의 개수)를 빼주고 다시 for문을 이용해서 더해주는 과정을 진행한다.
• 이 과정에서 while문에 들어온 경우에만 answer가 더해지는데 이때 인덱스에 +1을 해주어야한다.

문제 링크

문제 요약 🥈 실버 4

소수를 찾는 것과 관련된 문제로 에라토스테네스의 체 개념을 이용해서 풀이하면 되는 간단한 문제!

문제 풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class boj2581 {
    public static void main(String[] args) throws IOException{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int target1 = Integer.parseInt(br.readLine());
        int target2 = Integer.parseInt(br.readLine());

        ArrayList<Integer> prime_list = new ArrayList<>();

        for(int i=target1; i<target2+1; i++)
        {
            if(isPrime(i) && i != 1) //소수라면 
            {
                prime_list.add(i);
            }
        }

        int ans = 0;

        if(prime_list.size() == 0)
        {
            System.out.println(-1);
        }
        else
        {
            for(int i=0; i<prime_list.size(); i++)
            {
                ans += prime_list.get(i);
            }
            System.out.println(ans + " " + prime_list.get(0));
        }

   }

    private static boolean isPrime(int num)
        {
            for(int i =2; i<num; i++)
            {
                if(num % i == 0)
                {
                    return false;
                }
            }

            return true;
        }
}

📌 익숙해질 점

• 이제 꽤나 익숙해져서 익숙해질..게 많이 없는 것 같다(?) 뭐 함수 따로 만드는 정도?

문제 요약 🥈 실버 4

뭐 그냥 수열을 활용하는 문제라서 딱히 첨언할 게 없는 것 같다.

문제 풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class boj1292
{
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stk = new StringTokenizer(br.readLine());

        int start = Integer.parseInt(stk.nextToken());
        int end = Integer.parseInt(stk.nextToken());

        ArrayList<Integer> list = new ArrayList<>();

        int cnt = 1; 

        for(int i=1; i<1001; i++)
        {
            for(int j=1; j<i+1; j++)
            {
                list.add(cnt);
            }
            cnt ++;
        }

        int ans = 0;

        for(int i=start-1; i<end; i++)
        {
            ans += list.get(i);
            //System.out.println(list.get(i));
        }
        System.out.println(ans);

    }
}

📌 익숙해질 점

• 딱히 .. 그냥 파이썬 식으로 생각하다보니까 이중 for문으로 금방 풀린 문제

1. MySQL 설치

brew install mysql@8.0 이라는 명령어로 간단하게 설치 가능하다. brew가 없다면 우선 brew부터 설치하자 🍺

2. MySQL 서버 실행하기

brew services start mysql@8.0 명령어를 통해 서버를 시작할 수 있다.

그리고 brew services list 명령어를 통해 서버가 잘 실행되었는지 확인할 수 있다.

3. MySQL 서버 끄기

brew services stop mysql@8.0 명령어로 쉽게 서버를 끝낼 수 있다.

문제 요약 🥉 브론즈 2

브론즈 문제 치고는 어느정도의 아이디어가 필요한 Brute Force 문제이다. 가장 핵심적인 것은 9명의 난쟁이 키의 합을 구한 후에 2명 씩 더해서 뺐을 때, 100이 되는 경우에 정답을 출력하면 되는 문제이다.

문제 풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

public class boj2309
{
    /* 난쟁이의 키 합이 100이 됨 */
    public static void main(String[] args) throws IOException{
        BufferedReader rb = new BufferedReader(new InputStreamReader(System.in));

        ArrayList<Integer> dwarfs = new ArrayList<>(); //가짜 난쟁이 저장 정보
        int sum = 0;

        for(int i=0; i <9; i++)
        {
            int dwarf = Integer.parseInt(rb.readLine());
            sum += dwarf;
            dwarfs.add(dwarf);
        }

        Collections.sort(dwarfs); // 오름차순 정렬
        //System.out.println(dwarfs);

        for(int i=0; i<8; i++)
        {
            for (int j=1; j<9; j++)
            {
                if(sum-dwarfs.get(i)-dwarfs.get(j) == 100)
                {
                    /*그냥 단순제거해버리면 arrayList에 변화를 주기 때문에 index 에러 발생 */
                    dwarfs.set(i, 0);
                    dwarfs.set(j, 0);

                    Collections.sort(dwarfs); // 재정렬
                    for(int idx=2; idx<9; idx++)
                    {
                        System.out.println(dwarfs.get(idx));
                    }
                    return;
                }
            }
        }
    }
}

📌 익숙해질 점

• 개인적으로 ArrayList가 편해서 사용하는데 다른 분들은 그냥 array를 많이 사용하셨다.
• ArrayList에서 특정 인덱스의 값을 바꿔 줄 때는 .set을 사용하면 된다.
• ArrayList의 정렬은 Collections 모듈을 사용하면 되는데, Collections.sort(list);로 작성해주면된다.

문제 요약 🥉 브론즈 3

요약할게 없을 정도로 간단한 문제이다.

문제 풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class boj3460 {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int tc = Integer.parseInt(br.readLine());

        for(int i=0; i < tc; i++)
        {
            int target = Integer.parseInt(br.readLine());

            int index = 0;

            while(target>0)
            {
                if(target % 2 == 1)
                {
                    System.out.print(index + " ");
                }
                target /= 2;
                index ++;
            }
            System.out.println(); //줄바꿈
        }

    }

}

📌 익숙해질 점

• 띄어쓰기 없이 답을 출력하기 위해 System.out.print(); 를 사용했다는 점 ?

문제 링크

문제 요약 🥉 브론즈 3

요약할게 없을 정도로 간단한 문제이다.

문제 풀이

import java.util.StringTokenizer;
import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;;



public class boj2501{
    public static void main(String[] args) throws IOException{

        /* 입출력 */
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stk = new StringTokenizer(br.readLine()); // 읽은 라인을 ""으로 자른다 

        /*String Tokenizer*/
        int N = Integer.parseInt(stk.nextToken());
        int M = Integer.parseInt(stk.nextToken());

        ArrayList<Integer> number = new ArrayList<>();

        for(int i=1; i<=N;i++)
        {
            if(N % i == 0)
            {
                number.add(i);
            }
        }

        int num_size = number.size();
        if(num_size < M)
        {
            System.out.println(0);
        }
        else{
            System.out.println(number.get(M-1));
        }
    }
}   

📌 익숙해질 점

• BufferedReader로 읽어준는게 입력은 가장 빠르다고 한다.
• StringTokenizer를 이용해서 입력받은 값들을 각각 나누어서(?) 변수에 저장 가능하다.
• Python의 리스트와 가장 비슷한 역할을 하는 것이 ArrayList이므로 이를 많이 활용할 듯 (?)

String 정리 🖊️

• String은 한 번 만들어지면, 문자를 추가하거나 삭제할 수 없는 변경 불가능한 타입

  String my_str = "abcdef"; // java는 변수 앞에 형 선언
  

/* 문자열의 길이 */ my_str.length(); // 길이 반환 my_str.isEmpty(); // 길이가 0이면 True, 아니면 False 반환

/* 문자열 자르기 */ //(1) split 함수 my_str.split("c"); // split("분리할 문자열 기준") my_str.split(); // 띄어쓰기 없는 문자열 str을 한 문자씩 분리해서 배열 반환 my_str.split("c", 1); // ("분리할 문자열 기준", "배열의 크기 한정")

System.out.println(my_str.split("c")[0]); // "ab" 출력

String[] str1 = my_string.split("c"); // 반복문으로 자른 문자열의 배열 for (String s: str1){ // 배열에서만 가능한 for 문 System.out.println(s); // split 된 배열의 각 요소 출력 }

//(2) substring 함수 my_str.substring(2); // 해당 Index 문자열부터 출력 : "cdef" 출력 my_str.substring(0, 2); // start idx ~ end idx -1 까지 출력 : "ab" 출력

//(3) for 문 사용 for(int i = 0; i < my_string.length(); i ++) { my_string.charAt(i); //charAt 함수 : 해당 Index의 문자를 Return }

//(4) trim my_str.trim() // my_str의 앞 뒤 공백 제거, 문자열 사이의 공백은 제거 X

/* 대소문자 변경 */ String str = "HellO WOrlD!" str = str.toUpperCase(); // 문자열 전체 대문자로 : HELLO WORLD! str = str.toLowerCase(); // 문자열 전체 소문자로 : hello world! c = Character.toUpperCase('c'); //단일 문자 대문자로 c = Character.toLowerCase('C'); //단일 문자 소문자로

/char의 대소문자 확인/ char letter = 'a'; Charcter.isLowerCase(letter); //소문자니까 true 반환

/문자열 비교/ String s = "Starbucks"; s.equals("Starbucks"); // 같기 때문에 True , 아니라면 False 반환 s.equalsIgnoreCase("sta"); // 문자열 간의 대소문자를 무시하고 비교 후 값 반환 s.contains("buck"); // 포함되니까 True, 아니면 False 반환

s.startsWith("S"); // "S"로 시작하는지 s.endsWith("ks"); // "ks"로 끝나는지

/위치 찾기/ String text = "Hello, world!"; int index1 = text.indexOf("world"); // 문자열이 처음 나타나는 위치의 인덱스 반환 : 7 출력 int index2 = text.indexOf('o'); // 주어진 문자가 처음 나타나는 인덱스 반환 : 4 출력 int index3 = text.indexOf('o', 5); // 'o'라는 문자/문자열이 주어진 인덱스 5 이후에 처음으로 나타는 인덱스 반환 : 7 출력 int index4 = text.lastIndexOf("o"); // "o"문자의 마지막 인덱스 반환 : 8 출력

/형 변환/ Integer.parseInt("320") // 문자열 -> 숫자로 변환 : 출력 320 Integer.toString(320) // 숫자 -> 문자열로 변환 : 출력 "320"

/문자열 뒤집기/ String str = "hello"; String str = new StringBuilder(str).reverse().toString(); //출력 : olleh

### String Builder 정리 🖊️ 

* String과 다르게 변경 가능한 타입으로 **`문자열을 변경`**해야하는 문제에서 주로 사용!

```java
StringBuilder sb = new StringBuilder();

sb.append("abc"); // 문자열 추가
sb.insert(2, "dd"); // 인덱스 2 위치에 dd 추가 

sb.delete(0, 2); // 0~1 사이 인덱스에 위치한 문자열 삭제 
sb.deleteCharAt(2); // 인덱스 2에 위치한 문자열 삭제 

sb.setCharAt(0, 'f); // 인덱스 0에 위치한 문자를 f로 변경 

sb.reverse(); // 문자열 뒤집기

sb.setLength(2); // 문자열 길이를 2로 줄인다 -> "ab"로 바뀜
sb.setLength(4); // 문자열 길이를 4로 늘린다 -> 뒤가 공백으로 채워짐 

Array 정리 🖊️

• Array 의 특징 정리
  • 식별자 존재
  • 크기 할당 필수
  • 삽입/삭제: slow , 데이터 조회: fast

String[] weeks = new String[7]; // String 타입의 배열의 크기가 7
String[] weeks = {'월요일', '화요일', '수요일', '목요일', '금요일', '토요일', '일요일'}; 
weeks[2]; // '수요일' 출력 (인덱스로 접근 가능)
weeks.length;//배열의길이출력 
int[] ten_array = new int[10]; // int 타입의 배열 크기가 10

List 정리 🖊️

• List 의 특징 정리

  • 식별자가 없음 (앞의 요소 삭제되면 새로 추가되는 요소가 그 자리에 추가 가능)
  • 크기 할당 필요 없음
  • 삽입/삭제: fast , 데이터 조회: slow

List<String> list = new ArrayList<>();

list.add("서울"); //리스트 가장 뒤에 서울 삽입
list.add(1, "대전"); // 인덱스 1의 위치에 대전 삽입
list.addAll(list2) // list 뒤에 list2 전부 삽입! 

list.get(0); // 인덱스 0의 위치에 있는 값 반환 (서울)
list.set(0, "대구"); // 0위치의 값을 대구로 바꾸기 

list.indexOf("대구"); // 대구의 첫 인덱스 반환 
list.lastIndexOf("대구"); // 대구의 마지막 인덱스 반환

list.remove(0); // 0 위치의 값 삭제 
list.remove("대구"); // 첫 "대구" 값을 삭제 
list.removeAll(list2); // list에서 list2에 들어있는 모든 값을 삭제 
list.retainAll(list2); // list에서 list2에 들어있는 값을 제외하고 모두 삭제 

list.clear(); // 전체 초기화
list.isEmpty();// 길이가 0이면 True
list.size(); // 리스트의 길이 반환 

list.contains("서울"); // 서울이 list에 존재하면 true, 아니면 false 
list.containsAll(list2); // list에 list2의 모든 값이 포함되면 true

list.removeIf(k -> k%2 !=0) // 람다식으로 홀수를 list 에서 제거 

ArrayList 정리 🖊️

• ArrayList란? Array와 List의 장점을 각각 갖고 있다고 생각하면 편하다. 따라서, 배열의 특성인 index로 식별자 사용이 가능하고 리스트의 특성대로 크기를 동적으로 사용 가능하다. 즉, index를 사용할 수 있는 리스트 !

  /*선언*/
  ArrayList<자료형> 변수명 = new ArrayList<자료형>(크기);
  //new ArrayList 쪽 자료형, 크기 전부 생략 가능
  //ex(1): ArrayList<Integer> integer1 = new ArrayList<Integer>();
  //ex(2): ArrayList<Integer> integer1 = new ArrayList<>();
  //ex(3): ArrayList<Integer> integer1 = new ArrayList<>(Arrays.asList(1,2,3,4,5));
  

/추가/ integer1.add(6); /제거/ integer1.remove(0); //element 직접 입력 혹은 인덱스 입력 가능 /대체/ integer1.set(1, 'mon'); /정렬/ import java.util.Collections;

Collections.sort(integer1); // 오름차순 정렬

//그 외 string 비슷한 방법들로 handle 가능

### Array ↔︎ List 정리 🖊️ 

코딩테스트를 풀이할 때, 리턴 타입이 정해져있는 경우에 형 변환이 거의 필수적이므로 알아두자!

```java

/* 문자열 배열 -> List */
String[] tmp = "abcde";
List<String> list = new ArrayList<>(Arrays.asList(tmp));

/* List -> 문자열 배열 */
List<String> list = new ArrayList<>();
String[] tmp = list.toArray(new String[list.size()]));

/* 정수 배열 -> List */
int[] tmp = {123, 1222, 563, 7531};
List<Integer> list = new ArrayList<>(Arrays.asList(tmp));

/* List -> 정수 배열 */
List<Integer> list = new ArrayList<>();
int[] tmp = list.stream().mapToInt(i->i).toArray(); 

HashMap 정리 🖊️

파이썬의 딕셔너리 와 비슷한 친구를 Hash map이라고 생각해주면 될 것 같다! 즉, key-value로 데이터에 접근할 수 있는 강력한 툴이다.

• 값 추가 주의 점 : HashMap의 경우 저장공간보다 추가적으로 데이터가 들어오면 파이썬의 리스트처럼 공간을 늘리기는 하지만, 한 번에 약 2배로 늘리기 때문에 여기에서 과부하가 많이 발생한다고 한다! 따라서, 저장할 데이터의 개수를 알고 있다면, 미리 용량을 설정해주자 : )
• 값 삭제 주의 점 :

/*HashMap 선언*/
HashMap<Integer, Integer> map1 = new HashMap<Integer, Integer>(); // key와 value가 전부 integer 
HashMap<Integer, Integer> map1 = new HashMap<>(); //new에서 타입 파라미터 생략 가능
HashMap<Integer, Integer> map1 = new HashMap<>(10); // 초기 크기 설정 가능 
HashMap<String, String> map2 = new HashMap<>(){{
    put("key1", "value1");
    put("key2", "value2");
}}; //초기 값 설정

/*값 추가*/
HashMap<Integer, String> num_map = new HashMap<Integer, String>();
num_map.put(1, "one");
num_map.put(2, "two);

/*값 삭제*/
HashMap<Integer, String> num_map = new HashMap<Integer, String>(){{
    put(1,"One");
    put(2,"Two");
    }};
num_map.remove(2); // key값 2 제거 (오직 키 값으로만 제거 가능)
num_map.clear(); 

/*값 출력*/
HashMap<Integer, String> num_map = new HashMap<Integer, String>(){{
    put(1,"One");
    put(2,"Two");
    }};
System.out.println(num_map); // 전체 출력
System.out.println(num_map.get(1)); // key값이 1인 value 출력 


//entrySet을 활용한 출력 -- key, value 모두 필요할 때
for(Entry<Integer, String> entry: num_map.entrySet())
{
    System.out.println("[Key]= " + entry.getKey() + "[Value]= " + entry.getValue());
 }   

 //KeySet을 활용한 출력 -- key 값만 필요할 때 
//물론 keySet을 사용하더라도 value까지 추출이 가능하지만 시간 복잡도가 증가하므로 value까지 필요하다면 entrySet을 사용하자!
 for(Integer i: num_map.keySet()){
     System.out.println("[Key]= "+i + "[Value]= "+ num_map.get(i));
    }

num_map.containsKey(2); //특정 키 포함 여부

Queue 정리 🖊️

• 줄을 지어 기다리는 것처럼 처리되는 자료구조 즉, FIFO(First In First Out)

/*Queue 생성*/
Queue<Integer> queue = new LinkedList<>();
Queue<String> s_queue = new LinkedList<>();

/*add 과정*/
queue.add(1);
s_queue.add("wtf");
queue.offer(3);

/*꺼내기*/
int num1 = queue.poll();
String line = s_queue.poll();

/*queue의 첫번째로 들어간 값 참조*/
queue.peek();

Priority Queue 정리 🖊️

/*priority queue 선언*/
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(); //int형 priorityQueue 선언 (우선순위가 낮은 숫자 순)
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Collections.reverseOrder()); //int형 priorityQueue 선언 (우선순위가 높은 숫자 순)

/*priority queue 값 추가 및 제거 */
priorityQueue.add(3);
priorityQueue.offer(2);
---
priorityQueue.poll();
priorityQueue.remove();

/*priorityQueue에서 가장 우선 순위가 높은 값 출력*/
priorityQueue.peek();

작성 중 ...

[참고자료] https://velog.io/@db_jam/Java-%ED%95%B4%EC%8B%9C%EB%A7%B5HashMap-%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-%EC%A0%95%EB%A6%AC https://flexiblecode.tistory.com/212

대기업 공채는 처음이니까 나중에 보면 복기할 때 도움 될 것 같아서 😏 이번 하반기에는 대학원도 준비하고 취준도 병행하면서 머릿속이 많이 복잡하기도 하고 내가 경험한 일들을 잘 까먹는 느낌이 들어서 그나마 가장 최근 기억인 LG 전자.. 후기 작성 ON

우선 LG 전자 서류 합격을 받고 인적성 및 코딩 테스트를 언제 보고 싶은지 구글폼으로 작성해서 낸 후에 차례로 이메일이 도착한다. 나는 .. 빠르게 해치우고 싶기도하고 해보지도 않은 인적성 공부 더 오래 한다고 크게 결과가 달라질 것이라고 생각하지 않았기에 .. 인적성은 제일 빠른 날짜 그리고 코테는 그 다음 날 편한 시간대로 신청했다ㅎㅎ

📚 인적성 검사

• 시험 총 소요 시간: 2시간

• 시험 출제 유형: 언어이해, 언어추리, 자료해석, 창의추리 (각 15문제 씩 10분)
• 주의 사항: 프로그램 내장된 메모장, 그림판, 계산기만 사용 가능 (필기 불가)

1. 사전 점검 필수

      사전 점검과 관련된 정보들을 LG 채용 사이트 지원서에서 확인할 수 있다. 해당 페이지에서 프로그램을 다운 받고 사전 점검을 진행할 수 있는데, 이를 진행하지 않으면 인적성 검사를 진행할 수 없다. 시간도 얼마 안 걸리니까 기한 잘 확인하고 진행하기를 바란다.

2. 준비 방..법(?)

      나는 개발 직군이기도 하고 취업 준비를 처음 해봐서 인적성을 제대로 준비해 본 적이 없다.. ^^ 그래서 준비 방법이라고 하기에도 정말 민망할 .. 정도이다 ㅎ

아무튼 .. 준비를 어떻게 했냐면 .. 한 2-3일 전부터 친구가 공유해준 LG 인적성 e-book으로 준비를 진행했다. 유형 별로 어떻게 공부했다.. 라는 요령은 전혀 없었다 : )

내가 중요시 여기면서 준비했던 것은 "컴퓨터를 사용해서 시험보는 환경에 익숙해자" 였다. 짧은 시간 내에 문제를 읽고 답을 찍는 것 또한 상당히 부담스럽기는 했지만..ㅎㅎ 단기간 내에 극적인 점수 향상은 현실적으로 불가능 하기에 ^^

ㅎ..혹시나 해서 친구한테 공유해서 푼 인적성 e-book 링크 첨부! ✅   LG 인적성검사 최신기출유형+실전문제 문제 양이 엄청나게 많은 정도는 아니라서 한 2-3일만에 문제를 전부 풀이하긴 했다! 하하!

3. 시험 후기

      우선 시험 시작 전 대기 시간이 엄청 길다 ^^ .. 이 점 참고하길 😊 시험 시작이 3시라면 3시부터 30분 정도 주변 환경 점검, 신분증 제출 등을 진행한다. 음료도 안되고 주변에 종이도 있으면 안되니까 책상 정리를 미리하는 것이 좋다! 그리고 대기 시간 10분 전까지만 화장실을 다녀올 수 있으니 검사를 다 맡은 후에 시간이 좀 있다면 미리 화장실을 한 번 다녀오고 앉자!

    음 시험은 뭐 그냥 저냥 휙 지나간 기분이었다..! 15문제를 10분만에 풀어야한다는 압박이 조금 있었지만, 준비한 기간에 비하면 풀만했던 것 같기도.. 하다 ㅎ 그리고 인성 검사의 경우 무조건 모든 문항을 체크해야 하니 최대한 고민하지 않고 빠르게 주어진 시간 내에 해결하는거 추천 👍

📚 코딩테스트

• 시험 총 소요 시간: 2시간

• 시험 환경: 프로그래머스
• 문항 수: 3문제

1. 준비 방법

      우선, 프로그래머스로 코딩 테스트를 보기 때문에 프로그래머스를 활용해서 문제 풀이 진행을 많이 했다. LG 전자 코딩테스트는 다른 기업(삼성 말하는거임)에 비해 어려운 편은 아니기 때문에 LV2 ~ LV3 정도를 풀이했다. 민망하지만, 다른 분들도 도움이 되게끔 준비 기간(3~4일..?) 동안 풀이한 문제를 나열해보고자 한다.

LV1. 체육복 - 그리디 LV2. 큰 수 만들기 - 그리디 LV2. 조이스틱 - 그리디 LV2. 구명보트 - 그리디 BOJ. 2839번: 설탕배달 - 그리디 LV2. 전화번호 목록 - 해시 LV2. 의상 - 해시 LV2. H-Index - 정렬 LV2. 기능개발 - 스택/큐 LV2. 피로도 - 완전탐색 LV2. 모음사전 - 완전탐색 LV3. 네트워크 - BFS/DFS LV2. 괄호 변환 - 카카오기출 LV2. 기능개발 - 스택/큐

어렵지 않은 난이도에 유형 복습을 중점적으로 진행했다. 특히, 그리디 의 경우 자신 없는 분야라서 더 많이 풀이했다.

2. 시험 후기

    생각보다 어렵지 않았던 시험인 것 같다! 자세한 문제의 내용을 언급할 수는 없지만, 해시 / 수학(?) / 구현 문제로 구성되어 있었다. 삼성 코딩테스트를 준비하면서 구현 문제의 경우 많이 굴러서 그런지 오히려 구현 문제가 쉽고 해시 문제가 어려웠던 것 같다 ㅋㅋ 모래주머니 역효과 ㅎㅅㅎ

그래서 누군가 LG 전자 코딩테스트를 준비한다고 하면, 유형 별로 프로그래머스에서 문제를 풀어보면서 시험 환경에 익수해지고 유형 복습을 하는 것을 추천한다! 개인적으로 프로그래머스 LV.3 까지도 필요 없을 것 같은 느낌이지만 .. 구현 과 많이 친하지 않다면, LV.3으로 많이 단련하는 것도 나쁘지 않을 것 같다 .

문제 요약

"균형잡힌 괄호 문자열" p가 매개변수로 주어질 때, 주어진 알고리즘을 수행해 "올바른 괄호 문자열"로 변환한 결과를 return

• 균형잡힌 괄호 문자열: "("와 ")"의 개수가 같은 경우
• 올바른 괄호 문자열 : "("와 ")"의 괄호 짝이 모두 맞는 경우 균형잡힌 괄호 문자열이라면 아래 규칙을 따른다. ```

1. 입력이 빈 문자열인 경우, 빈 문자열을 반환합니다.
2. 문자열 w를 두 "균형잡힌 괄호 문자열" u, v로 분리합니다. 단, u는 "균형잡힌 괄호 문자열"로 더 이상 분리할 수 없어야 하며, v는 빈 문자열이 될 수 있습니다.
3. 문자열 u가 "올바른 괄호 문자열" 이라면 문자열 v에 대해 1단계부터 다시 수행합니다. 3-1. 수행한 결과 문자열을 u에 이어 붙인 후 반환합니다.
4. 문자열 u가 "올바른 괄호 문자열"이 아니라면 아래 과정을 수행합니다. 4-1. 빈 문자열에 첫 번째 문자로 '('를 붙입니다. 4-2. 문자열 v에 대해 1단계부터 재귀적으로 수행한 결과 문자열을 이어 붙입니다. 4-3. ')'를 다시 붙입니다. 4-4. u의 첫 번째와 마지막 문자를 제거하고, 나머지 문자열의 괄호 방향을 뒤집어서 뒤에 붙입니다. 4-5. 생성된 문자열을 반환합니다.

문제 풀이

def divide_brackets(w_str):
    start_str = 0
    end_str = 0 

    for i in range(len(w_str)):
        if w_str[i] == "(":
            start_str +=1
        else:
            end_str +=1
        if start_str == end_str:
            return w_str[:i+1], w_str[i+1:]

def check_str(brackets):
    bracket_stack = []
    # 올바른 괄호 문자열인지!
    for b in brackets:
        if b == "(":
            bracket_stack.append(b)
        else:
            if not bracket_stack:
                # 스택이 비어있는데 ")"가 들어온다면
                return False
            bracket_stack.pop() # 짝이 맞으니까 pop!

    return True

def solution(p):
    answer = ''

    # STEP 0) 빈문자열은 빈문자열 반환
    if len(p) == 0 :
        return ""

    # STEP 1) 올바른 괄호 문자열인지 체크 
    if check_str(p):
        return p

    # STEP 2) u, v 문자열로 나누기 
    u, v = divide_brackets(p)
    # STEP 3) u 가 올바른 괄호 문자열이면, v에 대해서 1단계부터 시작
    if check_str(u):
        return u + str(solution(v))
    else:
        # STEP 4) u가 올바른 괄호 문자열이 아니라면, 
        answer = "("+solution(v)+")"
        u = u[1:-1] # 첫번째 마지막 문자 제거 

        for i in u:
            if i == "(":
                answer +=")"
            else:
                answer +="("

        return answer

📌 고려해야할 점

• 주어진 문자열에 대해서 문자열 u, v로 쪼개주는 divide_brackets 함수 정의
• 올바른 괄호 문자열인지 확인해주는 check_str 함수 정의
• solution 함수 즉, main 함수를 재귀적으로 호출하는데, 과정에 따라서 순서대로 정의해주면 된다! 주석참고

문제 요약

코니는 매일 다른 옷 조합을 착용하는데 각 의상 종류별로 한 가지만 착용할 수 있음. (ex. 두 개의 안경을 동시에 착용할 수 없음) 코니는 적어도 하루에 한 가지 의상은 착용하고 착용한 의상의 일부만 다르더라도 다른 조합으로 간주. 주어진 2차원 배열 clothes는 코니가 가진 의상과 그 의상의 종류를 나타내고 목표는 가능한 서로 다른 옷 조합의 수를 반환하는 것

문제 풀이

def solution(clothes):

    clothing = dict()
    for c in clothes:
        item, key = c
        if key in clothing:
            clothing[key].append(item)
        else:
            clothing[key] = [item]
    # 딕셔너리 길이 = key 개수 

    with_items = 1
    for key, value in clothing.items():
        with_items *= (len(value)+1) # 아무것도 안 입는 경우 포함 
    return with_items-1 # 전부 안 입은 경우 제외 

📌 고려해야할 점

• 약간 딕셔너리 사용해서 문제를 푸는 스킬이 필요하다기 보다는 ...! 경우의 수 문제에 가까운 것 같은 느낌
• 주어지는 리스트에 대해서 의류의 종류를 key로 세부사항(?)을 value로 딕셔너리를 형성해준다!
• 주어진 옷들에 대해서 해당 의류의 종류 (Ex. 상의, 하의, 겉옷 등)를 안 입을 수 있다는 것을 고려하기 위해 +1을 하여 경우의 수를 구해주고 최종적으로 전부 안 입었을 경우를 제외(-1) 해준다. 약간 경우의 수 문제에서 전체 경우의 수에서 예외 하나 빼주는 적어도 유형 문제 느낌 ㅇㅇ

문제 요약

문제에서 네트워크는 컴퓨터들이 정보를 교환할 수 있도록 연결된 형태를 의미함. 예를 들어, 컴퓨터 A와 B가 연결되고, B와 C가 연결되면, A와 C는 간접적으로 연결된 것을 의미 함. 주어진 컴퓨터의 개수(n)와 각 컴퓨터 간의 연결 정보(computers 2차원 배열)를 바탕으로 네트워크의 총 개수를 반환하는 함수를 작성!

문제 풀이

def DFS(computer_num, computers, visited, n):
    visited[computer_num] = 1 # 해당 컴퓨터 방문처리 

    for i in range(n):
        if computers[computer_num][i] == 1 and not visited[i]:
            DFS(i, computers, visited, n)

# 연결되면 하나의 네트워크 
def solution(n, computers):
    ans = 0 
    visited = [0] *n # DFS에서 사용할 방문 체크 
    # DFS의 시작점이 딱히 정해져 있지 않다... ! 
    for i in range(n): 
        if not visited[i]:
            DFS(i, computers, visited, n)
            ans +=1

    return ans

📌 고려해야할 점

• 각 컴퓨터가 얼마나 많은 컴퓨터와 연결되었는지 확인하는 것이기 때문에 DFS로 접근
• 다만, 기존에 많이 풀던 DFS와는 다르게 시작점이 딱히 정해져있지 않다! 따라서, 컴퓨터 개수에 따라 for문을 돌면서 인덱스가 컴퓨터의 라벨이라고 생각하고 DFS에 보내주기!
• DFS에 들어가서 최대한으로 연결하고 연결된 컴퓨터 라벨을 방문한 것으로 처리해주고 돌아오면 그 때가 네트워크 1개 형성한 것!

문제 요약

여러 기능 개선 작업을 수행 중 각 기능은 완료도(진도)가 100%일 때만 서비스에 반영. 기능마다 개발 속도는 다를 수 있어, 나중에 개발된 기능이 먼저 완성될 수 있음 그러나, 기능들은 주어진 순서대로만 배포 가능. 즉, 뒤에 있는 기능이 앞서 완성되더라도 앞의 기능이 배포될 때 함께 배포

문제 풀이

from collections import deque

def check(queue, day):
    count = 0 

    for q in queue:
        if q <= day:
            count +=1
        else:
            return count
    return count

def solution(progresses, speeds):
    answer = []
    days = [] # 배포까지 필요한 일 수 

    for i in range(len(progresses)):
        # 남은 작업 진도로 전부 대체 
        progresses[i] = 100 - progresses[i]
        if progresses[i] % speeds[i] != 0:
            days.append(int(progresses[i]/speeds[i])+1)
        else:
            days.append(int(progresses[i]/speeds[i]))

    dayq = deque(days)

    while dayq:
        day = dayq.popleft() 
        tmp_count = check(dayq, day)
        for _ in range(tmp_count):
            dayq.popleft()
        answer.append(tmp_count+1)

    return answer

📌 고려해야할 점

• 전체 진행도에서 남은 진행도를 구하고 해당 기능의 개발 속도를 나누어서 새로운 리스트를 형성
• 새로운 리스트를 바로 dayq라는 deque 형태로 변형하여 popleft 기능을 활용

문제 요약

발표한 논문 n 편 중에 h번 이상 인용된 논문이 h편 이상이고 나머지 논문이 h번 이하 인용되었다면 h의 최댓값이 이 과학자의 h-index이다. h-index 값을 return

문제 풀이

def solution(citations):
    answer = 0

    h_index = sum(citations) // len(citations)
    count = 0
    while count < h_index:
        for i in range(len(citations)):
            if citations[i] >= h_index:
            # 해당 인덱스의 논문 인용횟수가 h_index 보다 크다면, 
                count +=1
        if count >= h_index:
        # h_index 이상 인용된 논문의 개수가 h_index 이상일 때,
            answer = h_index
        else:
        # 아니라면, h_index 1만큼 감소 / count 초기화
        # 1만큼 감소하는 이유 = h번 이상 인용된 논문의 개수가 h_index 미만이라는 뜻
            if h_index < 0:
                h_index = 0 
            h_index -=1
            count = 0

    return answer

📌 고려해야할 점

• h_index를 주어진 논문들의 인용 횟수의 평균으로 초기화 후 비교 진행
• 20분만에 테스트 케이스를 통과한 문제이기는 하다. 하지만, while문과 for문을 사용하고 테스트케이스 실행 속도 측면에서 느렸기 때문에 다른 분들의 코드를 확인했다. ⬇️

def solution(citations):
    answer = 0
    citations.sort(reverse=True)

    for i in range(len(citations)):              # H_index가 존재하고 H_index를 넘는 논문이 몇 개인지 구할때
        if(citations[i] < i+1):
            return i

    return len(citations)                     # 인용 횟수가 모두 같을때는 전체를 return

H-index에대한 이해를 한다면 충분히 나올 수 있는 풀이라고 생각한다. <1> 내림차순으로 정렬 <2> 인용횟수가 인덱스+1을 넘어가는 경우가 오면 해당 인덱스 return <3> 인용횟수가 모두 같으면 전체 길이를 return

더 자세한 설명은 아래 링크에 더 잘 설명되어있다! 바로 가기

문제 요약

전화번호부 phone_book가 주어지고 한 번호가 다른 번호의 접두어에 해당하면 False를 리턴하면 되는 문제이다.

문제 풀이

# 정답으로 제출한 코드 
def solution(phone_book):
    answer = True
    phone_book.sort()
    for i in range(len(phone_book)-1):
        if phone_book[i+1].startswith(phone_book[i]):
            answer = False
            return answer
    return answer

 # 효율성에서 시간초과가 발생한 코드 
 def solution(phone_book):
    answer = True
    phone_book.sort()

    for idx in range(len(phone_book)):
        num1 = phone_book[idx]
        for num2 in phone_book[idx+1:]:
            if num2.startswith(num1):
                # 번호 중복이 없으니까
                #  num2가 num1으로 시작한다면, 
                answer = False
                break
        if not answer:
            break

    return answer

📌 고려해야할 점

• 효율성 문제에서 시간 초과가 처음 발생한 코드의 경우 모든 전화번호부를 검사하는 방식으로 진행하기 때문에 시간 초과가 발생한 것 같다.
• 정렬 했다는 사실을 잘 인지하고 있었어야 했다 🙄

  [예시]
  phone_book = ['123', '3342', '12343'] phone_book.sort() &nbsp &nbsp # ['123', '12343', '3342']

  ---

  위의 예시를 통해 위에서 나는 phone_book을 정렬했기 때문에 '123'을 접두어로 갖는 전화번호는 바로 '123' 뒤에 존재해야한다! 그 뒤의 전화번호는 비교할 필요 없다! 만약 접두어로 갖고 있는 전화번호가 한 개라도 존재하면, False를 반환하면 되기 때문이다.