노력의 천재

[프로그래머스/Level 1] 크기가 작은 부분 문자

노력의천재 — Sat, 13 Jan 2024 14:17:12 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/147355

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

부분 문자열의 길이가 18자리가 될 수 있으므로 int의 범위가 넘어간다.

따라서 long long 타입으로 변환해야 하는 것이 중요

#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;

int solution(string t, string p) {
    int answer = 0;
    int tLen = t.size(), pLen = p.size();
    
    for (int i = 0; i < tLen - pLen + 1; i++) {
        ll num = stoll(t.substr(i, pLen));
        if (num <= stoll(p)) answer++;
    }
    
    return answer;
}

[프로그래머스/Level 1] 카드 뭉치

노력의천재 — Tue, 9 Jan 2024 12:02:02 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/159994

프로그래머스

programmers.co.kr

여러 해결 방법이 있겠지만, 큐를 활용하여 문제를 해결했다.

cards 입력 값들을 각각의 큐에 넣어준 후, goal을 순회하며 각 큐에서 front 값을 가져와 비교를 시작한다.

조건에 의하면 주어진 cards 입력 값들의 순서를 바꿀 수 없기 때문에, pop을 해서 가져온 front 값이 반드시 같아야만 한다.

만약 같지 않다면, 순서가 일치하지 않으므로 단어를 만들 수 없는 케이스가 된다.

#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <iostream>
using namespace std;

string solution(vector<string> cards1, vector<string> cards2, vector<string> goal) {
    queue<string> q1, q2;
    
    for (auto &card : cards1) {
        q1.push(card);
    }
    
    for (auto &card : cards2) {
        q2.push(card);
    }
    
    bool isPossible;
    for (int i = 0; i < goal.size(); i++) {
        isPossible = false;
        string card1 = q1.front();
        string card2 = q2.front();
        
        if (!q1.empty() && goal[i] == card1) {
            isPossible = true;
            q1.pop();
        } else if (!q2.empty() && goal[i] == card2) {
            isPossible = true;
            q2.pop();
        }
        
        if (!isPossible) return "No";
    }
    
    return "Yes";
}

[프로그래머스/Level 1] 가장 많이 받은 선물

노력의천재 — Sun, 7 Jan 2024 20:06:47 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/258712

프로그래머스

programmers.co.kr

카카오 기출

'선물을 주고 받은 기록이 없는 경우'가 "A -> B 1개", "B -> A 0개"도 포함된다고 이해 하였는데, 말 그대로 서로 0개 주고 받은 경우를 의미한다. (조건을 잘 못 이해해서 시간 많이 잡아먹음)

조건을 꼼꼼하게 잘 읽어보면 어렵지 않게 구현할 수 있을듯

#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <sstream>
using namespace std;

int check[51][51];

int solution(vector<string> friends, vector<string> gifts) {
    int answer = -2147000000;
    unordered_map<string, int> um, giveUm, receiveUm, giftUm;
    
    // 선물을 주고 받은 횟수 저장
    for (auto &gift : gifts) {
        um[gift]++;
    }
    
    // 추후 선물 지수 계산을 위해 이름별로 선물을 준 횟수와 선물을 받은 횟수를 각각 저장
    for (auto &it : um) {
        string from, to;
        stringstream ss(it.first);
        int cnt = it.second;
        
        getline(ss, from, ' ');
        getline(ss, to, ' ');
        
        giveUm[from] += cnt;
        receiveUm[to] += cnt;
    }
    
    for (int i = 0; i < friends.size(); i++) {
        for (int j = 0; j < friends.size(); j++) {
            if (i == j || check[i][j] == 1) continue;
            
            int fromToCnt = um[friends[i] + " " + friends[j]];
            int toFromCnt = um[friends[j] + " " + friends[i]];
                
            if (fromToCnt > toFromCnt) {
                giftUm[friends[i]]++;
                check[i][j] = 1;
            } else if (fromToCnt == toFromCnt) {
                int fromIndex = giveUm[friends[i]] - receiveUm[friends[i]];
                int toIndex = giveUm[friends[j]] - receiveUm[friends[j]];
                
                if (fromIndex > toIndex) giftUm[friends[i]]++;
                else if (fromIndex < toIndex) giftUm[friends[j]]++;
                
                check[i][j] = 1;
                check[j][i] = 1;
            }
        }   
    }
    
    // 최대값 구하기
    for (auto &it : giftUm) {
        answer = max(answer, it.second);
    }

    return max(answer, 0);
}

[프로그래머스/Level 1] 대충 만든 자판

노력의천재 — Thu, 4 Jan 2024 16:18:40 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/160586

프로그래머스

programmers.co.kr

keymap의 각 알파벳 별 순서를 map에 저장한 후, targets의 문자열을 만들 수 있는 최소 클릭 수를 구하였다.

이때 주어진 keymap에서 특정 문자열을 만들 수 없는 경우 -1을 리턴해야 하는데, 다음 케이스를 조심해야 한다.

keymap : ["BC"]

targets : ["AC", "BC"]

return : [-1, 3]

=> "BC"는 만들 수 있으므로 -1로 리턴하면 안된다. 따라서 이를 구분하기 위해 flag 값을 추가

#include <string>
#include <vector>
#include <unordered_map>
#include <iostream>
#include <algorithm>
using namespace std;

vector<int> solution(vector<string> keymap, vector<string> targets) {
    vector<int> answer;
    int size = keymap.size();
    unordered_map<char, int> m[size];
    
    for (int i = 0; i < keymap.size(); i++) {
        for (int j = 0; j < keymap[i].size(); j++) {
            if (m[i][keymap[i][j]] != 0) continue;
            m[i][keymap[i][j]] = j + 1;
        }
    }

    for (int k = 0; k < targets.size(); k++) {
        int sum = 0;
        bool isPossible = true;
        
        for (int i = 0; i < targets[k].size(); i++) {
            char ch = targets[k][i];
            int minCnt = 2147000000;
            
            for (int j = 0; j < size; j++) {
                if (m[j][ch] == 0) continue;
                minCnt = min(minCnt, m[j][ch]);
            }
            
            if (minCnt == 2147000000) {
                isPossible = false;
                break;
            }
            
            sum += minCnt;
        }
        
        if (isPossible) answer.push_back(sum);
        else answer.push_back(-1);
    }
    
    return answer;
}

[프로그래머스/Level 1] 바탕화면 정리

노력의천재 — Tue, 2 Jan 2024 22:56:05 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/161990

프로그래머스

programmers.co.kr

최소한의 이동거리를 갖는 한 번의 드래그로 모든 파일을 선택하기 위해선 규칙이 존재하는데,

각 파일의 x좌표와 y좌표의 최소값, 최대값을 찾은 후 시작점은 최소값들의 좌표로 구성하고, 끝점은 최대값들의 좌표로 구성한 후 각각 +1을 해주면 된다.

#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

vector<int> solution(vector<string> wallpaper) {
    vector<int> xPos, yPos;
    
    for (int i = 0; i < wallpaper.size(); i++) {
        for (int j = 0; j < wallpaper[i].size(); j++) {
            if (wallpaper[i][j] == '#') {
                xPos.push_back(i);
                yPos.push_back(j);
            }
        }
    }
    
    int xMin = *min_element(xPos.begin(), xPos.end());
    int yMin = *min_element(yPos.begin(), yPos.end());
    int xMax = *max_element(xPos.begin(), xPos.end());
    int yMax = *max_element(yPos.begin(), yPos.end());
    
    return {xMin, yMin, xMax + 1, yMax + 1};
}

[프로그래머스/Level 1] 공원 산책

노력의천재 — Tue, 2 Jan 2024 22:49:53 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/172928

프로그래머스

programmers.co.kr

주어진 크기 만큼 특정 방향을 이동할 때, 크기가 벗어나면 여태까지 이동했던 좌표 정보는 업데이트 되면 안되고 초기화 되어야 한다. 따라서 flag 처리를 통해 이를 구분하였다.

#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
using namespace std;

// N: 0, S: 1, W: 2, E: 3
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};

vector<int> solution(vector<string> park, vector<string> routes) {
    map<char, int> m = {
        {'N', 0}, {'S', 1}, {'W', 2}, {'E', 3}
    };
    
    int sx, sy;
    for (int i = 0; i < park.size(); i++) {
        for (int j = 0; j < park[i].size(); j++) {
            if (park[i][j] == 'S') {
                sx = i, sy = j;
                break;
            }
        }
    }
    
    int h = park.size();
    int w = park[0].size();
    for (int i = 0; i < routes.size(); i++) {
        char d = routes[i][0];
        int mv = routes[i][2] - '0';
        int x = sx, y = sy;
        bool flag = true;

        for (int j = 0; j < mv; j++) {
            int nx = x + dx[m[d]];
            int ny = y + dy[m[d]];
            
            if (nx < 0 || ny < 0 || nx >= h || ny >= w || park[nx][ny] == 'X') {
                flag = false;
                break;
            }
            
            x = nx, y = ny;
        }
        
        if (flag) sx = x, sy = y;
    }
    
    return {sx, sy};
}

[프로그래머스/Level 1] 달리기 경주

노력의천재 — Wed, 27 Dec 2023 16:36:39 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/178871

프로그래머스

programmers.co.kr

입력 값의 크기 범위가 크기 때문에 O(N^2)으로는 해결 불가하다고 판단하여,

선수 이름에 따른 순서를 저장하는 map, 선수 순서에 따른 이름을 저장하는 map을 각각 선언하여 O(N)으로 해결

#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
using namespace std;

vector<string> solution(vector<string> players, vector<string> callings) {
    vector<string> answer;
    map<string, int> m1; // {이름, 순서}
    map<int, string> m2; // {순서, 이름}

    for (int i = 0; i < players.size(); i++) {
        m1[players[i]] = i;
        m2[i] = players[i];
    }

    for (auto name : callings) {
        int idx = m1[name]; // 추월한 선수 순서
        string passedName = m2[idx - 1]; // 추월 당한 선수 이름    

        m1[name] = idx - 1;
        m1[passedName] = idx;
        m2[idx] = passedName;
        m2[idx - 1] = name;
    }

    for (int i = 0; i < players.size(); i++) {
        answer.push_back(m2[i]);
    }

    return answer;
}

개발자 취업 상담 신청안내 (마감)

노력의천재 — Mon, 10 Jul 2023 00:00:13 +0900

안녕하세요 여러분
제 블로그를 방문해주시는 분들 중 대부분이 다음과 같을 것이라고 예상되는데요!

- 개발을 공부하는 전공생/비전공생
- 개발자로 취업을 준비하는 취준생

이 분들을 대상으로 무료 개발자 취업 상담을 진행해보려고 합니다.
상담의 퀄리티를 위해서 두 분 정도, 한 시간 동안, 1대1로 진행하려 합니다.

개발자 취업 상담 시 가격

참고로 크몽 등에서는 현직 개발자와의 상담이 필요할 경우 최소 3만원 정도의 가격이 발생합니다. 이를 무료로 진행할 수 있으니 꽤 좋은 기회이지 않나요 ㅎㅎ (많은 관심 부탁드립니당...)

멘티의 경우 다음 조건을 만족하실 경우 1순위 대상입니다!

- 이력서, 포트폴리오가 준비되신 분 ★
- 취업이 간절하고 열정이 있으신 분 ★★
- 노쇼 안하고 시간 약속 잘 지시킬 수 있는 분 ★★★ (시간은 금입니다... ㅜㅜ)

개발자로서 취업을 하고 싶은데 방향을 모르거나 면접 질문 유형 등 궁금한 것들 여쭤보시면 됩니다 ㅎㅎ

참여를 희망하시는 분은 7월 9일까지 비밀댓글로 참여 신청을 남겨주세요!
(티스토리 계정이 있는 분만 참여 신청 받도록 하겠습니다.)

감사합니다

[프로그래머스/Level 1] 개인정보 수집 유효기간

노력의천재 — Mon, 10 Apr 2023 20:56:24 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/150370

프로그래머스

programmers.co.kr

카카오 기출

오늘 날짜와 각 약관의 유효기간을 일(day) 단위로 변환 후 비교하면 간단하게 해결 가능하다.

주의할 점은 유효기간 변환 후 -1을 해줘야한다.

#include <string>
#include <vector>
#include <sstream>
#include <map>
#include <algorithm>
#include <iostream>
using namespace std;

map<string, int> m;

vector<int> solution(string today, vector<string> terms, vector<string> privacies) {
    vector<int> answer;
    int year = stoi(today.substr(0, 4));
    int month = stoi(today.substr(5, 2));
    int day = stoi(today.substr(8, 2));
    int date = year * 12 * 28 + month * 28 + day;
    
    for (auto t : terms) {
        stringstream ss(t);
        string type;
        int period;
        ss >> type >> period;
        m[type] = period;
    }
    
    for (int i = 0; i < privacies.size(); i++) {
        string privacy = privacies[i];
        stringstream ss(privacy);
        string period, type;
        ss >> period >> type;
        
        int p_year = stoi(privacy.substr(0, 4));
        int p_month = stoi(privacy.substr(5, 2));
        int p_day = stoi(privacy.substr(8, 2));
        int p_date = p_year * 12 * 28 + (p_month + m[type]) * 28 + p_day - 1;
        
        if (date > p_date) {
            answer.push_back(i + 1);
        }
    }
    return answer;
}

배움에 돈을 아끼지 말 것

노력의천재 — Sun, 20 Nov 2022 22:19:20 +0900

내가 어렸을 때부터 엄마가 매번 해주셨던 말이 있다.

"배움에 돈을 아끼지 마라. 네가 투자한 그 돈이 미래에 10배, 100배 이상의 가치로 돌아올 것이다."

그리고 오늘, 나는 나의 인생을 바꾸기 위한 배움의 기회에 도전을 하기로 결심했다. 이 선택이 좋은 선택일지, 돈 낭비 일지는 잘 모르겠다. 그러나 도전하지 않으면 인생은 바뀌지 않을 것이다. 미래에 지난 일을 회상하는 날이 온다면, 오늘의 결정이 후회 없는 결정이길 바라본다.

열등비교와 우등비교

노력의천재 — Sun, 30 Oct 2022 18:12:19 +0900

인간은 누구나 강점과 약점을 가지고 있다. 그러나 인간은 자신이 가진 강점보다 약점에 집중하며 자신의 약점 때문에 본인이 특정한 일을 할 수 없다고 핑계거리를 찾는 경향이 있다. 이처럼 남과 나를 비교하며 남보다 내가 못할 수 밖에 없는 합리화의 변명을 지속적으로 찾아내는 태도를 열등비교라고 한다.

우리는 이러한 열등비교를 그만두고 자신만이 가지고 있는 강점을 극대화하려는 태도가 필요하다. 나의 삶을 원하는 방향으로 끌고 가기 위해서는 우등비교를 할 필요가 있다. 우등비교란 열등비교와는 반대로 자신이 그 일을 나보다 잘할 수 밖에 없는 이유를 찾는 태도다.

하고자 하는 자는 방법을 찾고, 하기 싫어하는 자는 핑계를 찾는다는 것을 명심하자.

[Java] JVM 메모리 구조(Runtime Data Area) 정리

노력의천재 — Mon, 17 Oct 2022 21:29:47 +0900

개요

자바 개발자로서 JVM 런타임 데이터 영역에 대한 이해는 매우 중요하다. 자바로 개발을 하면서 가장 무서운 에러중 하나는 OOM(OutOfMemoryError)이다. 이것은 JVM의 메모리 영역과 관련이 있기 때문에 JVM 내부의 메모리 영역이 어떻게 동작하는지에 대한 이해가 필요하다.

런타임 데이터 영역의 종류

이러한 6가지 JVM 런타임 데이터 영역은 두 개의 그룹으로 분류될 수 있다.

PC 레지스터, JVM 스택, 네이티브 메서드 스택은 스레드마다 독립적으로 할당된다. 이러한 영역들은 스레드가 생성될 때 같이 초기화되고, 스레드가 종료될 때 같이 회수된다.

힙 영역, 메서드 영역, 런타임 컨스탄트 풀은 공유자원이다. JVM이 실행될 때 초기화되고, 종료될 때 같이 회수된다.

PC(Program Counter) Register

일반적으로 컴퓨터 구조 용어에서 PC 레지스터는 현재 실행하고 있는 인스럭션을 가리킨다. (포인터 같은 개념이다.) JVM에서도 똑같은 의미로 사용된다. 자바는 멀티 스레드를 지원하기 때문에, 새로운 스레드가 생성될 때 마다 새로운 PC 레지스터가 생성된다. 현재 실행되고 있는 스레드의 상태를 포인터로 가리킨다. 만약 현재 네이티브 메서드를 실행하고 있다면, PC 레지스터의 값은 정의되지 않는다.

Java Virtual Machine Stacks

JVM 스택은 자바 JVM 프레임을 저장하기 위해 사용된다. JVM은 스택을 직접 조작하지 않고 단지 프레임을 저장하기 위한 저장소이다. 스택의 메모리 크기는 고정 크기와 가변 크기로 나뉜다. 가변 크기는 필요에 따라 동적으로 확장된다. 자바 JVM 프레임은 메서드가 호출될 때 생성되고, 다이나믹 링킹을 수행한다. JVM 스택은 스레드마다 생성되고 관리된다.

StackOverFlowError
- 고정 크기의 스택에서 발생하는 에러
- 프로그램 실행동안 메모리 사이즈가 부족할 때 발생
OutOfMemoryError
- 가변 크기의 스택에서 발생하는 에러
- 필요한 메모리를 확장하려는데 더이상 충분한 메모리가 존재하지 않을 때 발생

Heap Memory

힙 영역은 객체(인스턴스)를 저장하는데 사용된다. 힙 영역은 공유 영역이므로 여러 개의 스레드가 접근할 수 있다. 힙 영역은 JVM이 실행될 때 생성된다. GC에 의해 자동으로 메모리 반환 요청이 수행됩니다. (이것이 자바의 가장 큰 특징 중 하나이다.) 만약 런타임시에 메모리가 충분하지 않다면 OutOfMemoryError가 발생한다.

Method Area

일반적으로 메서드 영역은 힙 영역의 논리적인 부분을 담당한다. 그러나 이는 JVM의 구현자의 마음이다. 메서드 영역은 각각의 클래스 구조와 필드를 가진다. 그리고 static 구조와 필드 외에는 아무것도 없다. 또한 메서드, 생성자 정보, 런타임 컨스탄트 풀을 포함한다. 힙 영역과 마찬가지로 공유 영역이며, JVM의 생명주기와 같다. 만약 런타임시에 메모리가 충분하지 않다면 OutOfMemoryError가 발생한다.

Runtime Constant Pool

런타임 컨스탄트 풀은 메서드 영역 외부에 생성되며, 클래스나 인터페이스 생성시 JVM에 의해 생성된다. 런타임 컨스탄트 풀은 클래스, 인터페이스 별로 적용할 수 있는 컨스탄트 풀 테이블을 가지고 있고, 이는 리터럴을 포함한다.

Native Method Stacks

네이티브 메서드를 지원하는 JVM은 네이티브 메서드 스택을 가진다. 스레드마다 생성되며, 네이티브 메서드를 위해 사용된다. JVM에 의해 네이티브 메서드가 로드되지 않는다면, 네이티브 메서드 스택은 필요가 없다. 메모리 크기는 일반 JVM 스택과 유사하게 관리된다.

[Java] 자바 스트림(Stream) API 내부 동작 알아보기

노력의천재 — Fri, 14 Oct 2022 10:59:16 +0900

자바 스트림 작업은 모두 LinkedList 구조를 통해 내부적으로 저장되고 내부 저장 구조에서 각 단계에는 다음 구조를 따르는 비트맵이 할당된다. (Stream Flags)

Stream internal flags

SIZED : 스트림의 크기를 아는가?
DISTINCT : 스트림의 요소가 전부 중복이 없는가?
SORTED : 요소가 원래 순서대로 정렬되었는가?
ORDERED : 요소가 스트림화 되는 순서가 컬렉션에서도 유지되는가?

위와 같은 비트맵 정보를 통해 자바는 스트림 최적화를 실행하기 때문에 이는 매우 중요하다. 각각의 작업은 다른 비트맵을 지우고, 설정하고, 유지하게 된다.

예를들어, 스트림의 map 메서드같은 경우 데이터가 변경될 수 있으므로 DISTINCT와 SORTED 비트맵을 지운다. 그러나 스트림의 크기는 수정되지 않으므로 SIZED 비트맵은 유지된다. filter 메서드의 경우 스트림의 크기가 변경될 수 있다. 따라서 SIZED 비트맵은 지우지만, 데이터 구조는 수정하지 않으므로 SORTED와 DISTINCT 비트맵은 유지한다.

즉, 각 작업은 이전 단계의 비트맵과 변경된 비트맵을 결합하여 새로운 비트맵 set을 생성하게 된다. 이를 바탕으로 Apply 단계에서 일부 작업을 생략할 수 있다. 이를 이용하여 얻을 수 있는 성능 이점에 대해 아래 예제 코드로 살펴보자.

public class StreamOptimization {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        Integer[] arr = new Integer[1_000_000];

        for (int i = 0; i < 1_000_000; i++) {
            set.add(i);
            arr[i] = i;
        }

        long start = System.currentTimeMillis();

//        List<Integer> list = set.stream()
//                .distinct()
//                .collect(Collectors.toList());

        List<Integer> list = Arrays.stream(arr)
                .distinct()
                .collect(Collectors.toList());

        long end = System.currentTimeMillis() - start;

        System.out.println(end);
    }
}

첫번째 결과 : 41
두번째 결과 : 163

Set 컬렉션과 Integer 배열에 모두 같은 수를 넣어주고, 둘 다 중복값을 가지고 있지 않다. 그러나 둘의 스트림 연산을 비교해봤을 때 4배 정도의 성능 차이를 확인할 수 있다. 해당 결과가 나온 이유는 Set은 중복값을 절대 허용하지 않으므로 DISTINCT 비트맵이 1로 설정된다. 따라서 distinct 메서드가 실행되지 않는다. 그러나 Integer 배열은 특성상 중복값을 허용하므로 실제로는 중복값이 없더라도 DISTINCT 비트맵 값이 0으로 설정된다. 따라서 매번 distinct 메서드가 실행된다.

[Java] 자바로 인접행렬, 인접리스트 구현하기

노력의천재 — Thu, 13 Oct 2022 11:57:32 +0900

작성 코드

public class Main {

    static int n, m;
    static int[][] arr;
    static ArrayList<Integer>[] list;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        /* 배열 & 리스트 초기화 */
        arr = new int[n + 1][n + 1];
        list = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            list[i] = new ArrayList<>();
        }

        /* 인접행렬 & 인접리스트 생성 */
        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int from = Integer.parseInt(st.nextToken());
            int to = Integer.parseInt(st.nextToken());
            arr[from][to] = 1;
            arr[to][from] = 1;
            list[from].add(to);
            list[to].add(from);
        }

        /* 인접행렬 출력 */
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println("================================================");

        /* 인접리스트 출력 */
        for (int i = 1; i <= n; i++) {
            System.out.print(i + " : ");
            for (int j = 0; j < list[i].size(); j++) {
                System.out.print(list[i].get(j) + " ");
            }
            System.out.println();
        }
    }
}

입력 값

5 7
1 4
4 1
1 3
4 3
3 5
4 5
4 2

출력 결과

0 0 1 1 0
0 0 0 1 0
1 0 0 1 1
1 1 1 0 1
0 0 1 1 0
================================================
1 : 4 4 3
2 : 4
3 : 1 4 5
4 : 1 1 3 5 2
5 : 3 4

[Java/Spring] 롬복(Lombok)이란? 활용법 정리

노력의천재 — Wed, 12 Oct 2022 22:30:45 +0900

개요

lombok의 다양한 활용법을 정리해보는 시간을 가져볼까 한다. 자바를 이용하여 개발을 진행하다보면 반복적인 코드의 작성이 발생하는 경우가 있다. 예를들어, 데이터 클래스(Data Class)를 만들 때, 각각의 필드에 대한 getter & setter 메서드를 만들어 캡슐화 작업을 해줘야하고, 생성자 작성 등 번거롭다. 이때 lombok을 활용하면 아주 유용한데, 빌드 과정에서 특정 어노테이션에 따라 .class 파일에 자바 바이트코드를 자동으로 생성해줌으로써 위에서 언급한 번거로운 작업을 해결할 수 있다.

lombok을 사용하기 위한 사전 준비는 간단하다. maven 혹은 gradle 환경에 맞게끔 의존성을 다음과 같이 추가해주면 된다.

<!-- maven -->
<dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.20</version>
      <scope>provided</scope>
</dependency>

// gradle
configurations {
	compileOnly {
		extendsFrom annotationProcessor
	}
}

compileOnly 'org.projectlombok:lombok:1.18.20'
annotationProcessor 'org.projectlombok:lombok:1.18.20'

※ IntelliJ를 사용하는 경우 Plugins에서 lombok 설치를 사전에 완료한 후 의존성을 추가해야 한다.

@Getter, @Setter, @NoArgsConstructor, @AllArgsConstructor

자바에서 필드를 private으로 설정한 후, public 접근자로 getter & setter 메서드를 만들어 데이터를 캡슐화하는 것이 일반적인 관행으로 모두 잘 알고 있을 것이다. (Java Beans Pattern)

만약 필드가 계속해서 추가된다면, 이에 따라 getter & setter 메서드도 추가해줘야 하는 번거로움이 있다. 물론 IDE에서 getter & setter 메서드에 대한 자동생성을 지원해주긴 한다.

public class Book {

    private Long id;
    private String title;
    private String author;
    private String isbn;
    private int price;

    public Book() {
    }

    public Book(Long id, String title, String author, String isbn, int price) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.isbn = isbn;
        this.price = price;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}

그러나 예제에서 확인할 수 있는 것 처럼 코드가 너무 장황해진다. 심지어 해당 메서드들은 단순히 데이터에 접근하기 위한 용도이고 비즈니스 로직을 가지고 있지도 않다. 이러한 단점을 극복하기 위해 lombok을 적용해보도록 하자.

@AllArgsConstructor
@NoArgsConstructor
@Getter @Setter
public class Book {

    private Long id;
    private String title;
    private String author;
    private String isbn;
    private int price;
}

@Getter, @Setter 어노테이션을 추가하여 getter & setter 메서드를 자동 생성했고, @NoArgsConstructor, @AllArgsConstructor 어노테이션을 추가하여 빈 생성자와 모든 인자를 가진 생성자를 자동 생성하였다.

또한, 일부 속성에 접근하기 위한 getter & setter의 접근 지정자 단계를 설정할 수 있다.

@AllArgsConstructor
@NoArgsConstructor
@Getter @Setter
public class Book {

    @Setter(AccessLevel.PROTECTED) // == private Long getId() { return this.id; }
    @Getter(AccessLevel.PRIVATE) // == protected void setId(Long id) { this.id = id; }
    private Long id;
    private String title;
    private String author;
    private String isbn;
    private int price;
}

위와같이 설정하게 되면, getId 메서드는 private, setId 메서드는 protected로 설정된다. 추가로 생성자의 접근 지정자도 설정해줄 수 있다. 방법은 비슷하다.

@AllArgsConstructor(access = AccessLevel.PACKAGE)
@NoArgsConstructor(access = AccessLevel.PUBLIC)
@Getter @Setter
public class Book {
    
    private Long id;
    private String title;
    private String author;
    private String isbn;
    private int price;
}

위와같이 설정하게 되면 빈 생성자는 public(미설정시 default), 모든 인자를 가진 생성자는 package-private로 설정된다.

Lazy Getter

특정 값을 계산하거나 객체를 생성하는데 많은 자원과 비용이 드는 경우, Lazy Getter 라는 기능을 사용할 수 있다. Lazy Getter를 사용하면 최초에 getter를 호출할 때 expensive 자원에 대한 캐시 처리가 진행되고, 이후에 getter를 호출하면 캐싱된 값을 불러옴으로써 성능 향상을 가져올 수 있다.

@Slf4j
public class GetterLazy {

    @Getter(lazy = true)
    private final int[] cached = expensive();

    private int[] expensive() {
        log.debug("expensive start"); // 계산이 몇 번 이루어지는지 확인을 위한 로그
        Random random = new Random();
        random.setSeed(System.currentTimeMillis());
        int[] result = new int[1000000];
        for (int i = 0; i < result.length; i++) {
            result[i] = random.nextInt(1000); // 1000 미만의 랜덤 정수 리턴
        }
        return result;
    }
}

해당 예제는 1000 미만의 랜덤 정수 값을 1000000번 생성하여, 1000000 크기의 배열에 넣는 계산을 하는 메서드를 가지고 있는 클래스이다. 계산이 완료된 값을 cached라는 필드 값에 캐싱한다. 이제 테스트 코드를 통해 Lazy Getter가 제대로 동작되는지 확인해보자.

class GetterLazyTest {

    @DisplayName("실행 비용이 많이 드는 경우 Lazy Getter를 통해 캐시처리 할 수 있다.")
    @Test
    void lazyGetterTest() {
        // given
        GetterLazy getterLazy = new GetterLazy();

        // when
        int[] cached1 = getterLazy.getCached();
        int[] cached2 = getterLazy.getCached();
        int sum1 = calculateSum(cached1);
        int sum2 = calculateSum(cached2);

        // then
        assertEquals(sum1, sum2);

    }

    private int calculateSum(int[] cached) {
        int sum = 0;
        for (int i = 0; i < cached.length; i++) {
            sum += cached[i];
        }
        return sum;
    }
}

GetterLazy 객체를 생성한 후, 해당 객체에서 getter를 두번 호출한다. 그리고 각각의 getter를 통해 생성된 배열의 값을 토대로 합계를 구하여 두 합계가 같은지 비교하는 코드이다. Lazy Getter가 제대로 동작하지 않는다면 getter 호출 시 난수 값이 배열에 저장되므로 두 합계가 다를 것이다. 결과를 확인해보자.

GetterLazyTest 결과

테스트 코드 실행결과 getter를 두번 실행하여 얻은 두 배열의 원소 합계가 같은 것을 확인할 수 있고, expensive value를 계산하는 메서드의 실행 로그가 한 번 찍힌 것을 통해 getter를 최초로 호출했을 때만 해당 메서드가 실행된 것을 확인할 수 있다. 그렇다면 Lazy Getter를 적용할 때 주의점은 무엇이 있을까? lombok의 공식 가이드를 살펴보면 다음과 같은 문구를 확인할 수 있다.

lombok 공식 문서

Lazy Getter 기능을 사용하여 필드 값을 캐싱할 경우, 필드 값에 직접 접근해서는 안되며 반드시 lombok에 의해 생성된 getter를 통해 접근해야 한다고 안내하고 있다. getter를 통해 접근해야 하는 이유는 해당 필드가 AtomicReference 타입으로 래핑 되기 때문이고 만약 해당 필드가 자기 자신을 가리키게 되면, 해당 값이 null로 계산되게 될 것이고, 이 레퍼런스는 null을 참조하게 된다고 한다.

'lazy' requires the field to be private and final

실습을 진행하며 새롭게 알게된 가이드에 주의사항만 기재한 것이 아니라, Lazy Getter 적용시 필드에 직접 접근을 못하도록 컴파일러가 실제로 막아 주는 것을 확인하였다. public access level을 가진 특정 필드에 @Getter(lazy = true)로 설정하면 자바 컴파일러가 해당 필드는 private final로 둬야 한다며 위와같이 컴파일에러 메시지를 보여준다.

마지막으로 Lazy Getter를 적용하면 개발자가 멀티 스레드 환경에서의 동기화 이슈에 대하여 따로 코드를 추가해줄 필요가 없다. 이와 관련된 처리를 컴파일러가 자동으로 생성해준다. .class 파일을 살펴보도록 하자.

public class GetterLazy {
    private static final Logger log = LoggerFactory.getLogger(GetterLazy.class);
    private final AtomicReference<Object> cached = new AtomicReference();

    public GetterLazy() {
    }

    private int[] expensive() {
        log.debug("expensive start");
        Random random = new Random();
        random.setSeed(System.currentTimeMillis());
        int[] result = new int[1000000];

        for(int i = 0; i < result.length; ++i) {
            result[i] = random.nextInt(1000);
        }

        return result;
    }

    public int[] getCached() {
        Object value = this.cached.get();
        if (value == null) {
            synchronized(this.cached) {
                value = this.cached.get();
                if (value == null) {
                    int[] actualValue = this.expensive();
                    value = actualValue == null ? this.cached : actualValue;
                    this.cached.set(value);
                }
            }
        }

        return (int[])(value == this.cached ? null : value);
    }
}

위에서 언급했던 것처럼 데이터를 AtomicReference 타입으로 래핑하여 멀티스레드 환경에서 발생할 수 있는 동기화 이슈가 발생하지 않는다. 또한, 최초로 getter가 호출되어 expensive value에 대한 계산이 이루어질 때, lock을 걸어주는 것을 확인할 수 있다.

불변 객체(Immutable Object) 만들기

lombok을 이용하면 불변 객체를 비교적 쉽게 생성할 수 있다. 불변 객체란 객체의 생성 후 객체의 상태 값이 변경되지 않는 객체를 의미한다. 보통 setter를 제거하고 @Builder 어노테이션을 통한 빌더 패턴을 이용하는 것이 일반적이다.

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
public class Book {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(length = 50, nullable = false)
    private String title;
    @Column(length = 20, nullable = false)
    private String author;
    @Column(length = 30, nullable = false)
    private String isbn;

    @Builder
    public Book(Long id, String title, String author, String isbn) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.isbn = isbn;
    }
}

참고로 JPA에서는 프록시 생성을 위해서 기본 생성자를 반드시 하나를 생성 해야한다. 기본 생성자를 아무 이유 없이 열어두는 것(public)은 객체 생성 시 안전성을 심각하게 떨어트릴 수 있으므로, 접근 권한을 protected로 설정하여 외부에서의 생성을 막아주는 것이 좋다.

다시 본론으로 들어가 빌더 패턴을 사용하는 이유는 쉽게 말해 생성자의 장점과 setter의 장점을 모두 가지고 있기 때문이라고 설명할 수 있을 것 같다. 다음 예제를 통해 좀 더 알아보도록 하자.

// 생성자
Book book = new Book(1L, "lombok", "주인장숭황", "1234-5678");

// 빌더 패턴
Book book = Book.builder()
        .id(1L)
        .title("lombok")
        .author("주인장숭황")
        .isbn("1234-5678")				
        .build();

생성자를 통해 객체를 생성하는 경우 생성자에 들어갈 인자의 순서를 모두 맞춰줘야 한다. 현재는 인자가 4개밖에 되지 않아 어렵지 않지만, 인자가 점점 많아진다면 이에 대한 순서가 직관적으로 보이지 않는다는 단점이 있다. 또한, 객체를 생성할 때 필요한 인자의 조합 케이스가 모두 다를 것이다. 이에 대한 모든 경우의 수에 맞게 생성자를 생성해줘야 한다는 단점도 치명적이다.

그러나 빌더 패턴을 사용하면, 특히 lombok의 @Builder를 이용하면, 어노테이션을 추가하는 것 만으로 빌더 패턴을 자동으로 구현하여 어떤 인자에 무슨 값을 초기화할 것인지 직관적으로 확인할 수 있고, 심지어 순서를 지키지 않아도 된다. 게다가 인자의 경우의 수를 모두 고려하여 생성자를 작성할 필요도 없다.

추가로 @Value 어노테이션을 이용하여 불변 객체를 만드는 방법도 존재한다.

@Accessors(fluent = true)
@RequiredArgsConstructor
@Value
public class ImmutableObject {

    Long id;
    String name;
    String age;
}

위와같이 @Value 어노테이션을 설정하게 되면 해당 클래스의 필드를 모두 private final로 설정한다. 따라서 현재 setter가 없지만 setter를 생성한다해도 필드의 데이터 값을 변경할 수 없다.

@RequiredArgsConstructor는 final 키워드나 @NotNull 어노테이션이 붙은 필드의 생성자를 자동으로 생성해주는 어노테이션이다. 스프링에서 의존성 주입을 할 때 많이 사용하는 어노테이션인데, 좀 더 뒤에 예제를 통해 따로 살펴 볼 예정이다.

@Accesors 어노테이션 getter 혹은 setter를 Java Beans 방식과 다르게 생성해주는 어노테이션이다. 현재 예제에서는 fluent = true 옵션을 설정하였는데, 이렇게 하면 자바 14에서 새롭게 추가된 레코드의 getter 생성 형태를 갖게된다. (아래의 테스트 코드를 보면 이해가 갈 것이다.)

class ImmutableObjectTest {

    @DisplayName("lombok의 @Value 어노테이션을 활용해 불변 객체를 만들 수 있다.")
    @Test
    void makeImmutableObjectWithLombok() {
        // given
        ImmutableObject immutableObject = new ImmutableObject(1L, "주인장숭황", "secret... ");

        // when
				//immutableObject. // setter가 없다. (있어도 필드가 final이라 변경 불가)

        // then
        assertEquals(1L, immutableObject.id());
        assertEquals("주인장숭황", immutableObject.name());
        assertEquals("secret... ", immutableObject.age());
    }
}

ImmutableObjectTest 결과

겉보기에는 꽤 유용한 어노테이션인 것 같지만 실무에서 활용도가 높을지는 의문이다. 대부분의 실무 프로젝트에서 Web Layer - Service Layer - Data Layer 사이에서 데이터가 이동할 때 Entity → DTO 혹은 DTO → Entity의 변환 과정을 거치는데, 이 @Value 어노테이션을 이용하면 해당 작업이 불가능할 것으로 판단되기 때문이다. (이에 대한 실제 사용 사례 및 정보는 확인이 필요할 것 같다 ㅠ)

@ToString, @EqualsAndHashCode

lombok의 @ToString과 @EqualsAndHashCode 어노테이션을 추가하면 Object 클래스의 toString(), equals(), hashCode() 메서드를 자동으로 재정의해준다.

@ToString
@EqualsAndHashCode
public class Author {

    private Long id;
    private String name;
    private String surname;
}

사용법은 위와같이 간단하다. 특히 equals()와 hashCode() 메서드의 경우 재정의 하는 방법이 매우 어렵고 복잡한데, 이러한 과정을 단순하게 해준다. 해당 클래스의 .class 파일을 살펴보자.

public class Author {
    private Long id;
    private String name;
    private String surname;

    public Author() {
    }

    public String toString() {
        return "Author(id=" + this.id + ", name=" + this.name + ", surname=" + this.surname + ")";
    }

    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof Author)) {
            return false;
        } else {
            Author other = (Author)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                label47: {
                    Object this$id = this.id;
                    Object other$id = other.id;
                    if (this$id == null) {
                        if (other$id == null) {
                            break label47;
                        }
                    } else if (this$id.equals(other$id)) {
                        break label47;
                    }

                    return false;
                }

                Object this$name = this.name;
                Object other$name = other.name;
                if (this$name == null) {
                    if (other$name != null) {
                        return false;
                    }
                } else if (!this$name.equals(other$name)) {
                    return false;
                }

                Object this$surname = this.surname;
                Object other$surname = other.surname;
                if (this$surname == null) {
                    if (other$surname != null) {
                        return false;
                    }
                } else if (!this$surname.equals(other$surname)) {
                    return false;
                }

                return true;
            }
        }
    }

    protected boolean canEqual(Object other) {
        return other instanceof Author;
    }

    public int hashCode() {
        int PRIME = true;
        int result = 1;
        Object $id = this.id;
        int result = result * 59 + ($id == null ? 43 : $id.hashCode());
        Object $name = this.name;
        result = result * 59 + ($name == null ? 43 : $name.hashCode());
        Object $surname = this.surname;
        result = result * 59 + ($surname == null ? 43 : $surname.hashCode());
        return result;
    }
}

toString()의 경우 기본적으로 클래스 이름이 포함된 문자열과 쉼표로 구분된 각 필드 값이 반환되도록 재정의되어 있다. 참고로 JPA를 사용하는 환경에서 두 엔티티가 양방향 매핑으로 설계되어 있다면 @ToString을 사용함으로써 발생할 수 있는 무한 순환 참조를 조심해야 한다. 해당 문제가 발생한다면 @ToString(exclude = {”클래스명”})와 같이 설정하여 회피할 수 있다.

equals()와 hashCode()의 경우 구현시 반드시 지켜야 할 규칙들을 잘 준수하여 자동으로 생성되는 것을 확인할 수 있다. 또한, callSuper 옵션을 통해 equals()와 hashCode() 메소드 자동 생성 시 부모 클래스의 필드를 감안할지 안 할지에 대해서 설정할 수 있다. 즉, true로 설정하면 부모 클래스 필드 값들도 동일한지 체크, false로 설정(default)하면 자신 클래스의 필드 값들만 고려한다.

의존성 자동 주입(DI : Dependency Injection)

@RequiredArgsConstructor
@Service
public class BookService {

    private final BookRepository bookRepository;
    private final MailSender mailSender;

    /* @Autowired 및 생성자 생략 가능
    @Autowired
    public BookService(BookRepository bookRepository, MailSender mailSender) {
            this.bookRepository = bookRepository;
            this.mailSender = mailSender;
    } */

		...
}

lombok의 @RequiredArgsConstructor 어노테이션을 활용하면 @Autowired를 사용하지 않고도 DI를 구현할 수 있다.

@SneakyThrows

메서드 선언부에서 사용하는 throws 키워드를 명시하지 않아도 해당 어노테이션을 사용하면 checked exception을 던질 수 있다. 어노테이션으로 예외 클래스를 파라미터로 입력받는다. 어찌보면 유용해보이긴 하지만 공식 문서에 따르면 신중히 사용해야 하며 다음과 같이 특정 상황에 유용하다고 언급이 되어있는데, 예제를 통해 살펴보자.

public class SneakyThrowsObject {

    @SneakyThrows(UnsupportedEncodingException.class)
    public String utf8ToString(byte[] someByteArray) {
        return new String(someByteArray, "UTF-8");
    }

    @SneakyThrows
    public void run() {
        throw new Throwable();
    }
}

new String(someByteArray, "UTF-8")은 지원되지 않는 인코딩 타입에 대한 예외로 UnsupportedEncodingException이 던져질 수 있다고 선언되어 있으나 JVM 스펙에서는 UTF-8이 항상 사용 가능해야 하기 때문에 이 예외는 '발생할 수 없는' 예외다. 이런 경우 @SneakyThrows를 사용하면 유용하다고 한다.

또한, Runnable의 run() 메소드 안에서 발생한 예외는 모든 예외가 RuntimeException으로 묶여 던져지기 때문에(심지어 예외 메시지가 비어있는 경우 존재) 정상적인 예외 처리를 할 수 없다. 이럴 때도 @SneakyThrows 사용을 추천한다고 한다.

public class SneakyThrowsObject {
    public SneakyThrowsObject() {
    }

    public String utf8ToString(byte[] someByteArray) {
        try {
            return new String(someByteArray, "UTF-8");
        } catch (UnsupportedEncodingException var3) {
            throw var3;
        }
    }

    public void run() {
        try {
            throw new Throwable();
        } catch (Throwable var2) {
            throw var2;
        }
    }
}

.class 파일을 살펴보면 @SneakyThrows를 사용한 메서드에서 자동으로 try-catch문이 생성되는 것을 확인할 수 있다. 따라서 해당 메서드에서 예외가 발생하면 catch문에서 printStackTrace() 메서드를 호출한 것과 같이 예외를 출력한다.

@Cleanup

public class CleanupObject {

    public static void main(String[] args) throws IOException {
        @Cleanup
        InputStream input = new FileInputStream(args[0]);

        @Cleanup
        OutputStream output = new FileOutputStream(args[1]);

        byte[] b = new byte[10000];

        while (true) {
            int r = input.read(b);

            if (r == -1)
                break;

            output.write(b, 0, r);
        }
    }
}

FileInputStream, FileOutputStream 등과 같이 시스템 자원을 사용하는 클래스는 객체를 자원의 사용이 끝난 후 close() 메서드를 반드시 호출해야 한다. 보통 이 경우 try-catch-finally문의 finally 구문에 작성하는데, 이러한 번거로운 작업을 @Cleanup 메서드를 사용하면 자동으로 close() 메서드를 호출해준다.

@Synchronized

자바에서는 synchronized 키워드를 사용하여 임계 영역을 구현할 수 있다. 그러나 이 방법은 100% 안전하지 않으며 데드락을 발생시킬 수 있다. 이러한 단점을 극복하기 위해 @Synchronized 어노테이션을 활용할 수 있다.

public class SynchronizedObject {

    private final Object readLock = new Object();

    @Synchronized
    public static void hello() {
        System.out.println("world");
    }

    @Synchronized
    public int answerToLife() {
        return 42;
    }

    @Synchronized("readLock")
    public void foo() {
        System.out.println("bar");
    }
}

synchronized 키워드처럼 해당 어노테이션은 static 메서드, 인스턴스 메서드에서만 사용할 수 있다. 그러나 lock을 거는 단위가 다른데, synchronized는 this에 lock을 걸지만, @Synchronized 어노테이션은 $lock이라는 이름을 가진 특별한 private 필드에 lock을 건다.

해당 필드는 개발자가 작성하지 않았을 경우 lombok에 의해 자동으로 생성되고, 만약 static 메서드에 어노테이션을 사용하면 $LOCK이라는 이름을 가진 private 필드가 생성되어 lock을 건다. 원하는 경우 lock을 직접 만들 수 있는데, 이 경우 $lock, $LOCK은 자동으로 생성되지 않으며 직접 만든 lock을 @Synchronized의 파라미터로 설정 해줘야 한다.

public class SynchronizedObject {
    private static final Object $LOCK = new Object[0];
    private final Object $lock = new Object[0];
    private final Object readLock = new Object();

    public SynchronizedObject() {
    }

    public static void hello() {
        synchronized($LOCK) {
            System.out.println("world");
        }
    }

    public int answerToLife() {
        synchronized(this.$lock) {
            return 42;
        }
    }

    public void foo() {
        synchronized(this.readLock) {
            System.out.println("bar");
        }
    }
}

.class 파일을 살펴보면 hello() 메서드의 경우 static 메서드이므로, @Synchronized 어노테이션을 사용했을 때 $LOCK이라는 static 필드가 자동생성되고 lock이 걸린 것을 확인할 수 있다. awnswerToLife() 메서드의 경우 인스턴스 메서드이므로 $lock이라는 필드가 자동생성되고 lock이 걸렸다. 마지막으로 foo() 메서드의 경우 직접 만든 readLock이라는 lock이 걸린 것을 확인할 수 있다.

마무리

이렇게 lombok의 stable features 정리를 마무리 하였다. 많은 자바 개발자들이 lombok을 사용하고 있다. 불행히 나의 팀에서는 lombok을 사용하고 있진 않지만, lombok이 제공하는 편리하고 유용한 기능들을 정리해보는 시간을 가져봄으로써 lombok에 대한 이해도를 높일 수 있었다. 학습한 내용을 사이드 프로젝트에 잘 적용해볼 수 있도록 노력해야겠다

Reference

https://projectlombok.org/features/

Stable

projectlombok.org

https://www.baeldung.com/intro-to-project-lombok

Introduction to Project Lombok | Baeldung

A comprehensive and very practical introduction to many useful usecases of Project Lombok on standard Java code.

www.baeldung.com

https://auth0.com/blog/a-complete-guide-to-lombok/

A Complete Guide to Lombok

Let’s see everything you should know to start using Project Lombok. We will have a look at how to integrate it into your IDE and use it t...

auth0.com

[프로그래머스/Level 2] k진수에서 소수 개수 구하기

노력의천재 — Mon, 10 Oct 2022 17:13:42 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/92335

프로그래머스

programmers.co.kr

카카오 기출

입력받은 숫자 n을 k진수로 변환하는 것은 어렵지 않다. 그러나 주의해야 할 점이 두 가지 존재한다.

1. k진수로 변환된 수가 int의 범위를 벗어날 수 있다.

2. 단순히 2부터 k진수로 변환된 수 - 1 값을 하나씩 체크하며 소수 여부를 판단하면 TLE 발생할 수 있다.
(아마 1번 TC에서 TLE이 발생할 것이다.)

1번은 long long 타입을 사용함으로써 해결할 수 있고, 2번은 제곱근 수만큼만 비교하면 시간을 단축시켜 해결할 수 있다.

#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <iostream>
using namespace std;
typedef long long ll;

bool isPrime(string token) {
    if(token == "" || token == "1") return false;
    ll num = stoll(token);
    for(ll i = 2; i * i <= num; i++) {
        if(num % i == 0) return false;
    }
    return true;
}

string convert(int n, int k) {
    string num = "";
    while(1) {
        if(n == 0) break;
        num.insert(0, to_string(n % k));
        n /= k;
    }
    return num;
}

int solution(int n, int k) {
    int answer = 0;
    string num = convert(n, k);
    stringstream ss(num);
    string token;
    while(getline(ss, token, '0')) {
        if(isPrime(token)) answer++;
    }
    return answer;
}

[프로그래머스/Level 1] 신고 결과 받기

노력의천재 — Mon, 3 Oct 2022 18:54:07 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/92334

프로그래머스

programmers.co.kr

카카오 기출 (다시 풀기, ~~작년 공채 때 풀었는데 왜 못풀지? ㅋ~~)

신고 내역을 담을 map과 신고 결과를 기록할 map을 각각 선언하여 문제를 해결할 수 있다.

다음과 같이 입력 값이 주어졌다고 가정해보자.

["muzi frodo","apeach frodo","frodo neo","muzi neo","apeach muzi"], k = 2

신고 내역(key=신고자, value=피신고자 집합)

muzi : {"frodo", "neo"}

frodo : {"neo"}

apeach : {"frodo", "muzi"}

neo : {}

신고 결과(key=피신고자, value=신고자 집합)

muzi : {"apeach"}

frodo : {"muzi", "apeach"}

apeach : {}

neo : {"muzi", "frodo"}

2(k)번 이상 신고를 받은 frodo와 neo가 정지되며, 해당 유저들을 신고한 muzi에게 2번, apeach 1번, frodo 1번 메일이 전송된다.

※ 이중 for문이 나오는 곳에서 TLE이 발생할 수 있지 않나 의심할 수 있지만, set의 최대 크기가 id_list의 크기 이므로, O(n^2) 라도 1,000 * 1,000 = 1,000,000 라서 문제없다.

#include <string>
#include <vector>
#include <map>
#include <set>
#include <sstream>
#include <algorithm>
#include <iostream>
using namespace std;

map<string, set<string>> reportHash, resultHash;

vector<int> solution(vector<string> id_list, vector<string> report, int k) {
    vector<int> answer(id_list.size());
    for(auto r : report) {
        stringstream ss(r);
        string from, to;
        getline(ss, from, ' ');
        getline(ss, to, ' ');
        reportHash[from].insert(to);
        resultHash[to].insert(from);
    }
    
    for(int i = 0; i < id_list.size(); i++) {
        string id = id_list[i];
        for(auto report : reportHash[id]) {
            if(resultHash[report].size() >= k) answer[i]++;
        }
    }
    
    return answer;
}

[프로그래머스/Level 3] 등산코스 정하기

노력의천재 — Thu, 29 Sep 2022 23:39:18 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/118669

프로그래머스

programmers.co.kr

카카오 기출 (다시 풀기)

다익스트라 알고리즘이란 한 정점에서 다른 정점까지의 최단 거리를 구하는 알고리즘이다.

이를 해당 문제에 적용해본다면 다음과 같이 된다.

"한 출입구에서 다른 지점까지의 최소 intensity를 구하기"

이때 주의해야할 점은 결국 다익스트라 알고리즘은 최악의 경우 모든 정점을 방문하게 되는데, TLE 발생할 수 있다.

주목해야할 것은 '각 지점은 양방향 통행이 가능한 등산로로 연결'되어 있다는 점이다.

즉, 단방향만 생각하면 된다! 한 출입구에서 산봉우리까지의 단방향 최소 intensity를 구했다면, 산봉우리에서 출입구까지의 최소 intensity를 고려하지 않아도 된다는 의미다.

#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#include <iostream>
using namespace std;

vector<pair<int, int>> graph[50001];
int isSummits[50001], intensity[50001];

vector<int> solution(int n, vector<vector<int>> paths, vector<int> gates, vector<int> summits) {
    for(auto p : paths) {
        graph[p[0]].push_back({ p[1], p[2] });
        graph[p[1]].push_back({ p[0], p[2] });
    }
    
    for(auto s : summits) {
        isSummits[s] = 1;
    }
    
    for(int i = 1; i <= n; i++) {
        intensity[i] = -1;
    }
    
    priority_queue<pair<int, int>> pq;
    for(auto g : gates) {
        pq.push({ 0, g });
        intensity[g] = 0;
    }
    
    vector<pair<int, int>> tmp;
    while(!pq.empty()) {
        auto [weight, now] = pq.top();
        pq.pop();
        // cout << weight << " " << now << "\n";
        
        if(intensity[now] < weight) continue;
        
        if(isSummits[now] == 1) {
            tmp.push_back({ intensity[now], now });
            continue;
        }
        
        for(auto g : graph[now]) {
            auto [next, n_weight] = g;
            n_weight = max(weight, n_weight);
            if(intensity[next] == -1 || n_weight < intensity[next]) {
                intensity[next] = n_weight;
                pq.push({ intensity[next], next });
            }
        }
    }
    
    sort(tmp.begin(), tmp.end());
    
    return { tmp[0].second, tmp[0].first };
}

[프로그래머스/Level 2] 두 큐 합 같게 만들기

노력의천재 — Sat, 24 Sep 2022 23:09:02 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/118667

프로그래머스

programmers.co.kr

카카오 기출, 그리디 유형

sum1과 sum2를 구한 후 다음과 같이 그리디를 적용한다.

sum1 > sum2인 경우, q1 pop후 q2로 insert
sum1 < sum2인 경우, q2 pop 후 q1으로 insert

해당 방법이 왜 유요한지 검증해보자면, sum1과 sum2의 합이 같아야하므로 합이 큰 쪽에서 원소를 pop하여 작은 쪽으로 insert를 해줘야 최소 횟수로 두 합을 같게 만들 수 있기 때문이다.

추가로 주의할 점은 두 합을 같게 만들 수 없는 경우 예외처리를 하는 것인데, 단순히 '큐의 크기 * 2'만큼 시도를 해본 후 이때도 두 합이 같지 않으면 -1를 리턴하도록 처리를 하면 오답이 발생한다. 이는 하나의 큐가 모두 비워진 후 다시 해당 큐를 채우면서 탐색하는 경우가 있기 때문이다. 이런 경우 '큐의 크기 * 2' 범위가 넘어가므로, 넉넉하게 '* 3' 처리를 해주었다.

#include <string>
#include <vector>
#include <queue>
#include <numeric>
#include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;

ll sum1, sum2;

int solution(vector<int> queue1, vector<int> queue2) {
    sum1 = accumulate(queue1.begin(), queue1.end(), 0);
    sum2 = accumulate(queue2.begin(), queue2.end(), 0);
    
    queue<int> q1, q2;
    for(int i = 0; i < queue1.size(); i++) {
        q1.push(queue1[i]);
        q2.push(queue2[i]);
    }
    
    int answer = 0;
    int n = 3 * queue1.size();
    while(1) {
        if(answer == n) return -1;
        if(sum1 == sum2) return answer;
        
        if(sum1 > sum2) {
            q2.push(q1.front());
            sum1 -= q1.front();
            sum2 += q1.front();
            q1.pop();
            answer++;
        } else if(sum1 < sum2) {
            q1.push(q2.front());
            sum2 -= q2.front();
            sum1 += q2.front();
            q2.pop();
            answer++;
        }
    }
}

[프로그래머스/Level 1] 성격 유형 검사하기

노력의천재 — Sat, 24 Sep 2022 17:18:28 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/118666

프로그래머스

programmers.co.kr

카카오 기출

#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <iostream>
using namespace std;

string table[4] = {"RT", "CF", "JM", "AN"};
int score[8] = {0, 3, 2, 1, 0, 1, 2, 3};
map<char, int> m;

string solution(vector<string> survey, vector<int> choices) {
    string answer = "";
    for(int i = 0; i < choices.size(); i++) {
        int st = choices[i];
        if (st < 4) {
            m[survey[i][0]] += score[st];
        } else {
            m[survey[i][1]] += score[st];
        }
    }
    
    // for(auto it : m) {
    //     cout << it.first << " " << it.second << "\n";
    // }
    
    for(int i = 0; i < 4; i++) {
        if(m[table[i][0]] >= m[table[i][1]]) {
            answer += table[i][0];
        } else {
            answer += table[i][1];
        }
    }
    
    return answer;
}

[백준/BOJ] N과 M (1), (2), (3), (4), (5), (6), (7), (8), (9), (10), (11)

노력의천재 — Thu, 22 Sep 2022 21:50:16 +0900

N과 M (1)

https://www.acmicpc.net/problem/15649

15649번: N과 M (1)

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다. 수열은 사전 순으로 증가하는 순서로 출력해

www.acmicpc.net

#include <iostream>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <list>
#include <tuple>
#include <unordered_set>
#include <unordered_map>
#include <map>
#include <set>
#include <sstream>
#include <climits>
#include <cmath>
#include <cstring>
#include <numeric>
#include <algorithm>
#define lp1(i, x, n) for(int i = x; i <= n; i++)
using namespace std;
typedef long long ll;

int t, n, m, h, k, r, c, sz, sx, sy, x, y, z, answer = 2147000000, L, R, sum, a, b, f, s, g, u, d, cnt = 1;
int visited[10], selected[10];

void DFS(int now, int cnt) {
	if(cnt == m) {
		for(int i = 0; i < cnt; i++) {
			cout << selected[i] << " ";
		}
		cout << "\n";
		return;
	}
	
	for(int i = 1; i <= n; i++) {
		if(visited[i] == 0) {
			visited[i] = 1;
			selected[cnt] = i;
			DFS(i, cnt + 1);
			visited[i] = 0;
		}
	}
}


int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n >> m;
	DFS(1, 0);
}

N과 M (2)

https://www.acmicpc.net/problem/15650

15650번: N과 M (2)

www.acmicpc.net

#include <iostream>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <list>
#include <tuple>
#include <unordered_set>
#include <unordered_map>
#include <map>
#include <set>
#include <sstream>
#include <climits>
#include <cmath>
#include <cstring>
#include <numeric>
#include <algorithm>
#define lp1(i, x, n) for(int i = x; i <= n; i++)
using namespace std;
typedef long long ll;

int t, n, m, h, k, r, c, sz, sx, sy, x, y, z, answer = 2147000000, L, R, sum, a, b, f, s, g, u, d, cnt = 1;
int visited[10], selected[10];

void DFS(int now, int cnt) {
	if(cnt == m) {
		for(int i = 0; i < cnt; i++) {
			cout << selected[i] << " ";
		}
		cout << "\n";
		return;
	}
	
	for(int i = now; i <= n; i++) {
		if(visited[i] == 0) {
			visited[i] = 1;
			selected[cnt] = i;
			DFS(i, cnt + 1);
			visited[i] = 0;
		}
	}
}


int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n >> m;
	DFS(1, 0);
}

N과 M (3)

https://www.acmicpc.net/problem/15651

15651번: N과 M (3)

www.acmicpc.net

#include <iostream>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <list>
#include <tuple>
#include <unordered_set>
#include <unordered_map>
#include <map>
#include <set>
#include <sstream>
#include <climits>
#include <cmath>
#include <cstring>
#include <numeric>
#include <algorithm>
#define lp1(i, x, n) for(int i = x; i <= n; i++)
using namespace std;
typedef long long ll;

int t, n, m, h, k, r, c, sz, sx, sy, x, y, z, answer = 2147000000, L, R, sum, a, b, f, s, g, u, d, cnt = 1;
int visited[10], selected[10];

void DFS(int now, int cnt) {
	if(cnt == m) {
		for(int i = 0; i < cnt; i++) {
			cout << selected[i] << " ";
		}
		cout << "\n";
		return;
	}
	
	for(int i = 1; i <= n; i++) {
		if(visited[i] >= 0) {
			visited[i]++;
			selected[cnt] = i;
			DFS(i, cnt + 1);
			visited[i]--;
		}
	}
}


int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n >> m;
	DFS(1, 0);
}

N과 M (4)

https://www.acmicpc.net/problem/15652

15652번: N과 M (4)

www.acmicpc.net

#include <iostream>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <list>
#include <tuple>
#include <unordered_set>
#include <unordered_map>
#include <map>
#include <set>
#include <sstream>
#include <climits>
#include <cmath>
#include <cstring>
#include <numeric>
#include <algorithm>
#define lp1(i, x, n) for(int i = x; i <= n; i++)
using namespace std;
typedef long long ll;

int t, n, m, h, k, r, c, sz, sx, sy, x, y, z, answer = 2147000000, L, R, sum, a, b, f, s, g, u, d, cnt = 1;
int visited[10], selected[10];

void DFS(int now, int cnt) {
	if(cnt == m) {
		for(int i = 0; i < cnt; i++) {
			cout << selected[i] << " ";
		}
		cout << "\n";
		return;
	}
	
	for(int i = now; i <= n; i++) {
		if(visited[i] >= 0) {
			visited[i]++;
			selected[cnt] = i;
			DFS(i, cnt + 1);
			visited[i]--;
		}
	}
}


int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n >> m;
	DFS(1, 0);
}

5 ~ 11 업데이트 예정 ...

수원 곡반정동 수제버거 맛집 버거플리 후기

노력의천재 — Tue, 20 Sep 2022 12:10:22 +0900

네이버 지도

버거플리

map.naver.com

주인장은 수제버거 및 햄버거를 사랑한다. 취미가 네이버맵에 수제버거 맛집, 햄버거 맛집을 검색해보는 것인데, 어느 날 보지못한 수제버거 집이 생긴 것을 확인하였다. 이건 못참지! 재택근무를 할 때 대표 메뉴인 그릴드머쉬룸버거를 먹어보았다.

그릴드머쉬룸버거(사진 잘 못찍어서 ㅈㅅ합니다.)

가격은 단품 기준 10,300원, 그릴드머쉬룸버거의 내용물은 다음과 같이 구성되어 있다.

소고기 패티
구운 느타리 버섯(그릴드 머쉬룸)
베이컨
치즈
토마토 등

맛에 대한 후기를 남겨보자면 개인적으로 패티가 마음에 들었다. 일부 수제버거의 경우 패티에 비계와 힘줄이 너무 많이 들어가서 맛이 없는데 이 곳의 패티는 그렇지 않다. 양념에 절여진 느타리 버섯과 패티의 조합이 잘 어울렸다. 결론은 꽤 맛있다. 재료도 신선한게 느껴졌는데, 후기를 남기면서 찾아보니 소고기를 제외한 내용물은 대부분 원산지가 국내산으로 재료에 꽤나 신경을 쓴 게 느껴진다.

버거플리 매장 내부 인테리어

매장 내부 인테리어도 감각적으로 꾸민 것 같아 가족들과 직접 방문도 해봤는데, 실물이 더 힙하다. 사장님이 흰색과 파란색 처돌이인게 분명하다. (+애플)

플리 버거

이때는 가장 기본 메뉴인 플리버거를 시켜봤는데, 패티가 좀 탄 것 같아 아쉬웠다. 그래도 여전히 맛은 훌륭했다. 오히려 기본 메뉴가 재료 본연의 맛을 살리는 것 같아 담백하게 먹기 좋았던 것 같다.

주인장 추천도 : ★★★☆☆

오픽(OPic) IH를 단기간에 취득하는 방법

노력의천재 — Tue, 20 Sep 2022 12:00:45 +0900

취업 시장에서의 오픽 중요도 증가

많은 취업 준비생들이 원하는 기업에 취업하기 위해 어학 자격증을 취득하고 있다. 이는 과거부터 지금까지 대기업, 공기업 등 대부분의 기업들이 지원자로부터 어학 자격증을 요구하고 있기 때문일 것이다. 그러나 과거와 비교했을 때 달라진 점이 존재한다. 예전에는 기업이 토익 점수를 요구 했다면, 요즘은 오픽, 토익 스피킹 등 영어 회화 역량을 요구하고 있다는 것이다.

삼성전자 신입사원 채용공고

예를들어 취준생들이 가장 가고 싶은 기업 중 하나인 삼성전자의 케이스를 살펴보자. 채용 공고를 살펴보면 대놓고 오픽 IL 이상 토익 스피킹 레벨 5 이상만 지원 가능하다고 안내 되어있다. 그 외에도 많은 기업들이 스피킹 점수를 활용하고 있으며, 몇몇 기업은 가산점을 주기도 한다. (오픽 활용 기업들)

즉, 특별한 경우가 아니라면 오픽 혹은 토익 스피킹 점수를 취득하는 것이 좋은데, 영어, 특히 영어 회화와는 비교적 거리가 먼 몇몇 공대생들은 원하는 스피킹 점수를 취득하는데 어려움을 겪고 있을 것이라고 생각된다. 이런 공대생들을 위해 내가 독학으로 오픽 IH를 단기간에 취득할 수 있었던 방법을 공유해보려고 한다.

효율적인 주제 선정

오픽은 시험 전에 서베이를 통해 주제를 선정한다. 효율적으로 주제를 선정하기 위해선 겹치는 주제를 선택하는 것이 좋다. 겹치는 주제가 무엇일까? 예를 들어 영화보기, 공연보기, 콘서트보기는 키워드만 다를 뿐 비슷한 주제라고 할 수 있다. 마찬가지로 조깅, 걷기, 하이킹/트래킹도 키워드만 다를 뿐 비슷한 유형의 발화가 만들어질 것이다. 이들이 겹치는 주제이며, 이렇게 주제를 선정하면 우리가 연습해야 할 범위를 줄여주고 시험의 난이도도 비교적 낮출 수 있는 장점이 있다.

추가로 본인이 자신없는 주제는 선택하지 않는 것을 추천한다. 본인의 경우 아싸였기 때문에 ㅠ 대학교 관련 질문이 나오면 아는게 1도 없어서... 할 말이 너무 없었다. 따라서 학생 질문에 아니요, 강의 수강 질문에 수강 후 5년 이상 지남을 선택하였다.

주제 선정이 모두 끝나면 난이도를 설정하는데, IH를 목표로 한다면 5-5가 가장 적절하다.

두괄식으로 말하기

오픽 IH 받기 위해 가장 중요한 것은 두괄식으로 말하는 연습을 하는 것이다. 대부분의 경우 미괄식으로 답변을 하는 경향이 있는데, 이럴 경우 청자의 입장에서 답변의 요점이 무엇인지 파악하기 어렵다. 두괄식으로 답변할 때의 가장 큰 장점은 답변의 범위를 좁힐 수 있다는 점이다. 답변하고자 하는 핵심을 정하면 대화의 흐름이 여러 갈래로 흩어지지 않고 하나의 방향으로 나아갈 수 있다.

두괄식으로 답변하는 방법을 간단한 예시로 알아보자. 주제는 날씨, 당신이 있는 곳의 계절은 어떻고 어떤 계절을 가장 좋아하는지 물어봤다고 가정한다.

"Korea has 4 seasons and I would like to say that spring is one of my favorite."

질문에 대한 답변으로 한국은 4계절을 가지고, 봄을 가장 좋아한다고 결론을 먼저 제시하였다. 이렇게 하면 핵심 요점이 나왔기 때문에 청자가 대화를 따라가는데 큰 도움이 된다. 우리는 정해진 방향 그대로 대화를 이어가면 된다.

"The reason why I love spring is it's so good weather to go on a picnic. I'm not kinda person who go out recently, but in spring, I become an active person. Because going on a picnic in spring makes me happy, It's like a heaven for me ~~~"

봄을 좋아하는 이유가 소풍을 가기에 너무 좋은 날씨이며, 원래 밖을 잘 나가지 않지만 봄에는 활동적인 사람이 되며, 봄에 소풍을 가서 행복하다고 감정 표현도 넣어주었다. 이처럼 두괄식으로 결론, 핵심 요점을 먼저 답변하면 뒤에는 이를 뒷받침하는 내용만 계속해서 더해주면 된다. 이것이 두괄식이 중요한 이유이다.

대화, 감정 표현의 중요성

오픽은 회화 시험이다. 더 나아가 비교적 가벼운 회화 시험이며, 친구와 대화하듯 자연스럽게 발화할 필요가 있다. 문법의 정확도? 물론 중요하다. 그러나 대화를 이어가는 것은 훨씬 더 중요하다. accuracy가 아닌 fluency에 더 집중하도록 하자. 문장 사이마다 filler words를 추가하고 감정을 나타내는 다양한 표현을 사용하는 것을 잊지말자. 이는 오픽 감독관에게 스크립트의 내용을 암기하여 대답하는 것이 아닌 자연스럽게 대화하는 느낌을 전달하여 플러스 요인이 될 수 있다.

filer words

Well ~
Umm ~
You know ~
You know what ~
I mean ~
I guess ~
I was like ~
It's like ~
Literally, Totally, Clearly ~
or something ~
You see ~
What am I trying to say ~
...

감정을 나타내는 형용사들

fantasic
shy
satisfied
joyful
confident
thoughtful
confused
peaceful
nervous
annoyed
depressed
disappointed
embarrassed
horrible
worried
lonely
...

돌발 주제(과거와 현재 비교) 팁

마지막으로 돌발 주제를 대처하는 팁을 공유하려 한다. 돌발 주제란 서베이 선택 란에는 없지만 시험에서 갑작스럽게 출제되는 문제 유형을 의미하며, 건강, 날씨, 은행, 재활용 등 넓은 범위를 가진다. 이때 질문의 유형은 주로 묘사/경험/비교 구성으로 주제당 3개를 물어본다.

대부분의 오픽 응시자들이 묘사/경험 질문의 경우 어찌저찌 대답을 해내지만, 비교 질문에서는 많이들 무너지는 경향이 있다. 이해가 가는게 진짜 할 말이 없기 때문이다. 갑자기 어렸을 때 은행과 지금 은행 비교 해보라고 하면 멘붕이 안올 수가 없다. 그러나 어떠한 비교 질문이 나오더라도 사용할 수 있는 만능 키워드가 존재하는데, 이 만능 키워드는 바로 스마트폰이다. 정확히는 스마트폰으로 인한 과거와 현재의 변화이다.

왜 스마트폰이 만능 키워드인지 아까 언급했던 은행 비교 문제를 통해 알아보자. 스마트폰 키워드를 이용해서 은행 비교 문제를 다음과 같이 답할 수 있다.

"When I was young, I could see lots of banks near my hometown. And whenever I needed to open a bank account or transfer my money to somewhere, I had to get to the one of the banks ~~~"

먼저 과거에 대한 은행에 대해 묘사를 해본다. 예전에는 은행이 많았고, 계좌를 만들거나 돈을 송금할 때 은행을 가야하며, 뒤에도 이런식으로 발화를 이어나가본다. 과거와 현재 비교에서는 과거에 대한 묘사를 길게할 필요는 없다고 생각하므로 간단하게 말해본다.

"But thanks for development of a smartphone, it has been changed now."

이제 현재로 넘어가는 기준점이 된다. 스마트폰의 발전 덕분에, 은행에 대한 변화가 있음을 암시한다.

"Nowadays, I don't have to get to the bank for something with banks. With my smartphone, I can do everything super easily, opening a bank account, transferring my money something like that ~~~"

현재에 대한 묘사로 넘어왔다. 오늘날은 은행 관련 업무를 하기 위해 은행에 갈 필요가 없고, 스마트폰이 있으면 모든 은행 업무를 볼 수 있으며, 뒤에도 스마트폰 키워드와 연관지어 발화를 이어나가면 된다. 예를 들어 스마트폰으로 업무를 보게 될 경우 시간이 단축되고 혜택이 있다는 장점을 묘사할 수도 있겠고, 이로인해 과거에 비해 은행의 수가 줄어드는 추세라는 것을 설명해도 좋을 것이다.

과거와 현재의 재활용을 비교해보라는 문제가 나온다면 어떨까?

"과거에는 사람들이 재활용을 중요하게 생각하지 않았고, 이에 대한 정보를 얻는 것이 어려웠지만, 스마트폰 기술이 발전하면서 오늘 날 사람들은 환경오염에 대한 심각성에 노출되어 있고, 재활용에 대한 관심이 높아지고 있다 ~~~"

이처럼 스마트폰을 키워드로 답변을 할 경우, 어떻게든 대화를 이어나갈 수 있다는 장점이 있다. 스마트폰의 발전으로 인하여 우리의 삶에 정말 큰 변화가 있었기 때문에 스마트폰을 키워드로 과거와 현재를 비교한다면 어떠한 돌발 주제가 나오더라도 비교적 쉽게 질문에 대한 발화를 이어나갈 수 있는 것이다.

마무리

이렇게 내가 독학으로 오픽 IH를 단기간에 취득할 수 있었던 방법, 팁을 공유해보았다. 물론 본인이 영어를 잘하는 편이라고는 생각하지 않는다. AL을 취득한 사람도 많을 것이고, 유학을 다녀온 사람들도 많이 있을 것이다. 그럼에도 불구하고, 오픽 IH가 간절한 취준생들도 있을 것이라고 생각된다. 그런 취준생들에게 해당 게시글이 조금이나마 도움이 되어 오픽 IH를 취득하고, 원하는 기업에 취뽀할 수 있기를 바란다

오픽 IH

[Spring] 정적 파일 로드시 URL에 jsessionid가 붙는 경우 해결

노력의천재 — Sat, 10 Sep 2022 12:13:34 +0900

개요

보안팀으로부터 back office 프로그램에 대한 동적 테스트를 진행해달라는 요청사항을 받아 테스트를 진행하던중, 정적 파일 로드시 URL에 jsessionid가 붙어 XSS 공격으로부터 취약하다는 검진 결과가 나왔다.

해결 방법

톰캣, 즉 서버 입장에서는 웹 브라우저의 쿠키 지원 유무를 모르기 때문에 쿠키값도 전달하고 URL에 jsessionid도 함께 전달하는 것이 원인이었다. 따라서 서버쪽에서 URL 전달 방식은 비활성화하고 쿠키를 통해서만 세션을 유지하도록 설정을 해주면 더이상 URL에 jsessionid가 노출되지 않는다.

스프링 MVC를 사용할 경우

# web.xml
<session-config>
	<tracking-mode>COOKIE</tracking-mode>
</session-config>

스프링 부트를 사용할 경우

# application.properties
server.servlet.session.tracking-modes=cookie

# application.yml
server:
  servlet:
    session:
      tracking-modes: cookie

TDD(Test-Driven Development) 공부 정리

노력의천재 — Wed, 7 Sep 2022 22:15:19 +0900

TDD(Test-Drivent Development)란?

테스트 주도 개발, 테스트로부터 시작하는 개발 방식을 의미한다.

실패하는 테스트 코드를 작성하고,
테스트를 통과시킬 만큼 구현한 후,
리팩토링하는 작업을 반복한다.

TDD의 장점

테스트 코드가 있으면 문제 범위를 좁혀서 디버깅하는게 수월하다.
리팩토링 등 코드를 수정할 때 실패하는 테스트 코드가 발생하면 문제를 빨리 찾아낼 수 있다.
테스트가 가능하려면 의존 대상을 대역(Mock)으로 교체할 수 있어야 하는데, 대역으로 교체할 수 있는 구조는 역할별로 잘 분리되어 있는 설계 구조를 가졌다고 볼 수 있다.

예제 코드 1

/**
 * 암호화 검사기 TDD 예제
 * 
 * 사용하는 규칙
 *  - 길이가 8글자 이상
 *  - 0 ~ 9 사이 숫자 포함
 *  - 대문자 포함
 * 세 규칙을 모두 충족하면 '강함'
 * 두 규칙을 충족하면 '보통'
 * 하나 이하의 규칙을 충족하면 '약함'
 * 
 * 시연 진행 순서
 * 1. 테스트 클래스와 메서드 작성, 실행
 * 2. null 입력에 대한 테스트로 시작 (테스트 대상 타입 정의, 메서드 정의, 결과 타입 정의)
 * 3. 빈 값에 대한 테스트
 * 4. 모든 조건을 충족하는 테스트
 * 5. 두 조건을 충족하는 테스트
 * 6. 한 조건을 충족하는 테스트
 * 7. 아무 조건도 충족하지 않는 테스트
 */
class PasswordMeterTest {

    @DisplayName("null 입력에 대한 테스트")
    @Test
    void nullInputTest() {
        assertPasswordStrength(null, PasswordStrength.INVALID);
    }

    @DisplayName("빈 값에 대한 테스트")
    @Test
    void emptyInputTest() {
        assertPasswordStrength("", PasswordStrength.INVALID);
    }

    @DisplayName("모든 조건을 충족하는 테스트")
    @Test
    void meetAllRulesTest() {
        assertPasswordStrength("abcdABCD123", PasswordStrength.STRONG);
        assertPasswordStrength("123ABCD123", PasswordStrength.STRONG);
        assertPasswordStrength("abcd123ABCD", PasswordStrength.STRONG);
    }
    
    @DisplayName("두 조건을 충족하는 테스트(길이 규칙 위반)")
    @Test
    void meet2RulesExceptForLengthRuleTest() {
        assertPasswordStrength("abc12AB", PasswordStrength.NORMAL);
        assertPasswordStrength("AB12a", PasswordStrength.NORMAL);
        assertPasswordStrength("12ABab", PasswordStrength.NORMAL);
    }

    @DisplayName("두 조건을 충족하는 테스트(숫자 규칙 위반)")
    @Test
    void meet2RulesExceptForDigitRuleTest() {
        assertPasswordStrength("abcdABCD", PasswordStrength.NORMAL);
        assertPasswordStrength("ABCDabcd", PasswordStrength.NORMAL);
        assertPasswordStrength("abABcdCD", PasswordStrength.NORMAL);
    }

    @DisplayName("두 조건을 충족하는 테스트(대문자 규칙 위반)")
    @Test
    void meet2RulesExceptForUpperCaseRuleTest() {
        assertPasswordStrength("abcd1234", PasswordStrength.NORMAL);
        assertPasswordStrength("abcd1234", PasswordStrength.NORMAL);
        assertPasswordStrength("ab12cd34", PasswordStrength.NORMAL);
    }

    @DisplayName("오직 한 조건을 충족하는 테스트")
    @Test
    void meetOnlyLengthRuleTest() {
        assertPasswordStrength("abcdefghijk", PasswordStrength.WEAK);
        assertPasswordStrength("abcdefgh", PasswordStrength.WEAK);
        assertPasswordStrength("abcd!@#$%", PasswordStrength.WEAK);
    }

    @DisplayName("아무 조건도 충족하지 않는 테스트")
    @Test
    void meetNoRuleTest() {
        assertPasswordStrength("abc", PasswordStrength.WEAK);
        assertPasswordStrength("abcd", PasswordStrength.WEAK);
        assertPasswordStrength("abcd!@", PasswordStrength.WEAK);
    }

    private void assertPasswordStrength(String password, PasswordStrength expected) {
        PasswordMeter passwordMeter = new PasswordMeter();
        PasswordStrength result = passwordMeter.meter(password);
        assertThat(result).isEqualTo(expected);
    }
}

public class PasswordMeter {

    private final Pattern digitPattern = Pattern.compile("[0-9]");
    private final Pattern upperCasePattern = Pattern.compile("[A-Z]");

    public PasswordStrength meter(String password) {
        if (password == null || password.isEmpty()) {
            return PasswordStrength.INVALID;
        }

        int meetCnt = getMeetCnt(password);

        if (meetCnt == 0 || meetCnt == 1) {
            return PasswordStrength.WEAK;
        }

        if (meetCnt == 2) {
            return PasswordStrength.NORMAL;
        }

        return PasswordStrength.STRONG;
    }

    private boolean hasDigit(String password) {
        return digitPattern.matcher(password).find();
    }

    private boolean hasUpperCase(String password) {
        return upperCasePattern.matcher(password).find();
    }

    private boolean meetLength(String password) {
        return password.length() >= 8;
    }

    private int getMeetCnt(String password) {
        int meetCnt = 0;
        if (meetLength(password)) {
            meetCnt++;
        }

        if (hasDigit(password)) {
            meetCnt++;
        }

        if (hasUpperCase(password)) {
            meetCnt++;
        }
        return meetCnt;
    }
}

예제 코드 2

/**
 * 회원 승인 API
 *
 * 대기 상태의 회원을 승인하면 회원 상태로 활성화 됨
 *
 *                              / - MemberRepository - MemoryMemberRepository
 * API - ConfirmMemberService
 *                              \ - Member
 *                              
 */
@SpringBootTest
@AutoConfigureMockMvc
public class MemberApiIntegrationTest {

    @Autowired
    private MemberRepository memberRepository;

    @Autowired
    private MockMvc mockMvc;

    @DisplayName("")
    @Test
    void confirm() throws Exception {
        // arrange (given)
        memberRepository.save(new Member("id", MemberStatus.WAITING));

        // act (when)
        mockMvc.perform(post("/members/{id}/confirm", "id"))
                .andExpect(status().isOk());

        // assert (then)
        Member m = memberRepository.findById("id");
        assertThat(m.getStatus()).isEqualTo(MemberStatus.ACTIVE);
    }
}

@RestController
public class MemberApi {

    private final ConfirmMemberService confirmMemberService;

    public MemberApi(ConfirmMemberService confirmMemberService) {
        this.confirmMemberService = confirmMemberService;
    }

    @PostMapping("/members/{id}/confirm")
    public ResponseEntity<?> confirm(@PathVariable("id") String id) {
        confirmMemberService.confirm(id);
        return ResponseEntity.ok("OK");
    }
}

@MockBean(JpaMetamodelMappingContext.class)
@WebMvcTest(MemberApi.class)
public class MemberApiTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private ConfirmMemberService confirmMemberService;

    @DisplayName("")
    @Test
    void shouldCallService() throws Exception {
        // when(테스트 실행)
        mockMvc.perform(post("/members/{id}/confirm", "id"))
                .andExpect(status().isOk());

        // then(검증)
        BDDMockito.then(confirmMemberService)
                .should()
                .confirm("id");
    }
}

@Service
public class ConfirmMemberService {

    private final MemberRepository memberRepository;

    public ConfirmMemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

    public void confirm(String id) {
        Member member = memberRepository.findById("id");
        if (member == null) {
            throw new MemberNotFoundException();
        }
        member.confirm();
    }
}

public class ConfirmMemberServiceTest {

    public static final String ID = "id";
    private MemberRepository memberRepository = new MemoryMemberRepository();
    private ConfirmMemberService confirmMemberService = new ConfirmMemberService(memberRepository);

    @BeforeEach
    public void initData() {
        memberRepository.deleteAll();
    }

    @DisplayName("")
    @Test
    void noMember() {
        Assertions.assertThatCode(() -> {
            confirmMemberService.confirm(ID);
        }).isInstanceOf(MemberNotFoundException.class);
    }

    @DisplayName("")
    @Test
    void memberAleadyActivated() {
        memberRepository.save(new Member(ID, MemberStatus.ACTIVE));

        Assertions.assertThatCode(() -> {
            confirmMemberService.confirm(ID);
        }).isInstanceOf(MemberAlreadyActivatedException.class);
    }

    @DisplayName("")
    @Test
    void confirm() {
        // arrange (given)
        memberRepository.save(new Member(ID,MemberStatus.WAITING));

        // act (when)
        confirmMemberService.confirm(ID);

        // assert (then)
        Member m = memberRepository.findById(ID);
        assertThat(m.getStatus()).isEqualTo(MemberStatus.ACTIVE);
    }
}

[Java] 다형성을 이용하여 null 처리하기

노력의천재 — Tue, 30 Aug 2022 00:05:28 +0900

개요

자바를 이용하여 개발하면 NPE(NullPointerException)을 방지하기 위해 null 체크를 하여 예외 로직을 작성하는 일이 잦다. 자바 8부터는 Optional API를 통해 좀 더 편리하고 깔끔하게 null 처리를 할 수 있지만, 현재 나의 팀에서는 자바 8을 사용하고 있지 않기 때문에 이를 활용할 수 없었다. 이러한 문제점을 해결하기 위해 다형성을 이용한 null 처리를 적용하였고, 다형성을 이용해서 어떻게 null 처리가 가능한 지 공유하려고 한다.

일반적인 null 처리

실습의 내용은 고객이 신한/하나/현대/삼성 카드 중 유효한 카드를 체크하여 결제를 진행한다고 가정한다.

public interface Card {

    void pay();
}


public class ShinhanCard implements Card {

    @Override
    public void pay() {
        System.out.println("신한카드로 결제합니다.");
    }
}


public class HanaCard implements Card {

    @Override
    public void pay() {
        System.out.println("하나카드로 결제합니다.");
    }
}


public class HyundaiCard implements Card {

    @Override
    public void pay() {
        System.out.println("현대카드로 결제합니다.");
    }
}

먼저 각 카드의 최상위 인터페이스에 pay 메서드를 정의하고, 각 카드사마다 클래스를 생성하여 pay 메서드를 재정의한다.

public class Client {

    private List<Card> cardList;

    public Client(List<CardType> cardTypeList) {
        this.cardList = CardChecker.getValidatedCardList(cardTypeList);
    }

    public List<Card> getCardList() {
        return cardList;
    }
}

고객은 카드 리스트 중 유효한 카드를 cardList에 보관한다.

public enum CardType {

    SHINHAN, HANA, HYUNDAI, SAMSUNG
}


public abstract class CardChecker {

    private CardChecker() {
    }

    protected static List<Card> getValidatedCardList(List<CardType> cardTypeList) {
        List<Card> result = new ArrayList<>();
        for (CardType company : cardTypeList) {
            switch (company) {
                case SHINHAN:
                    result.add(new ShinhanCard());
                    break;
                case HANA:
                    result.add(new HanaCard());
                    break;
                case HYUNDAI:
                    result.add(new HyundaiCard());
                    break;
                default:
                    result.add(null);
            }
        }

        return result;
    }
}

카드사를 enum 타입으로 정의하고, CardChecker에서 for문을 돌며 List에 담긴 카드가 유효한 카드인지 체크한 후, 이를 다시 List에 담아 리턴한다.

이제 위에서 작성한 코드를 사용해보자.

class ClientTest {

    @Test
    void 일반_null_처리_테스트() {
        // 고객은 4개의 카드사 중 유효한 카드 리스트를 얻는다.
        List<CardType> cardTypeList = Arrays.asList(CardType.SHINHAN, CardType.HANA, CardType.HYUNDAI, CardType.SAMSUNG);
        Client client = new Client(cardTypeList);

        // 고객이 가지고 있는 카드사별 카드로 결제한다.
        List<Card> cardList = client.getCardList();
        for (Card card : cardList) {
            // 클라이언트 코드에서 null 체크가 필요하다.
            if (card == null) {
                System.out.println("지원되지 않은 카드사의 카드를 가지고 있습니다.");
            } else {
            	// 결제 로직
                card.pay();
            }
        }
    }
}

CardChecker 클래스에서 신한, 하나, 현대 카드는 유효한 카드로 검증하기 때문에 고객은 이에 해당하는 카드 객체를 가지고 있을 것이고, 삼성 카드는 유효하지 않으므로 null 값을 가지고 있을 것이다. 따라서 위의 코드처럼 null 체크를 통해 null일 경우의 분기 로직을 따로 정의해줘야 한다.

현재 예제처럼 단순한 경우에는 null 체크를 하는 것이 나쁜 것은 아니다. 그러나 해당 비즈니스 로직이 다양한 클라이언트 코드에서 호출된다면, 매번 null 체크를 포함하게 될 것이다. 이런 번거롭고 반복되는 작업은 다형성을 이용하면 손쉽게 해결할 수 있다.

다형성을 이용한 null 처리

public class NullCard implements Card {

    @Override
    public void pay() {
        System.out.println("지원되지 않은 카드사의 카드를 가지고 있습니다.");
    }
}

Card를 구현하는 NullCard 클래스를 만들고 신한, 하나, 현대가 아닌 다른 카드사의 경우 실행될 비즈니스 로직을 재정의한다.

public abstract class CardChecker {

    private CardChecker() {
    }

    protected static List<Card> getValidatedCardList(List<CardType> cardTypeList) {
        List<Card> result = new ArrayList<>();
        for (CardType company : cardTypeList) {
            switch (company) {
                case SHINHAN:
                    result.add(new ShinhanCard());
                    break;
                case HANA:
                    result.add(new HanaCard());
                    break;
                case HYUNDAI:
                    result.add(new HyundaiCard());
                    break;
                default:
                    result.add(new NullCard());
            }
        }

        return result;
    }
}

CardChecker 클래스에서 이전에 List에 담긴 카드가 유효하지 않을 경우 null을 리턴할 List에 담았다면, 이를 null을 담는 것이 아닌 새롭게 구현한 NullCard 객체를 담는다.

class ClientTest {

    @Test
    void null_클래스_처리_테스트() {
        // 고객은 4개의 카드사 중 유효한 카드 리스트를 얻는다.
        List<CardType> companyList = Arrays.asList(CardType.SHINHAN, CardType.HANA, CardType.HYUNDAI, CardType.SAMSUNG);
        Client client = new Client(companyList);

        // 고객이 가지고 있는 카드사별 카드로 결제한다.
        List<Card> cardList = client.getCardList();
        for (Card card : cardList) {
            card.pay();
        }
        
        // null 체크가 필요 없어짐
    }
}

이런식으로 리팩토링을 진행하면 CardChecker 클래스에서 신한, 하나, 현대 카드는 유효한 카드로 검증하기 때문에 고객은 이에 해당하는 카드 객체를 가지고 있을 것이고, 삼성 카드는 유효하지 않으므로 NullCard 객체를 가지고 있을 것이다. 이는 null 값이 아니므로 null 체크 로직이 필요 없어지지만, 로직 실행 결과는 동일하게 유지된다.

마무리

간단한 예제를 통해 다형성을 이용하여 null 처리를 어떻게 할 수 있는지를 살펴보았다. null 체크는 나쁜 것이 아니라 꼭 필요한 부분이다. 그러나 null 체크와 연관된 특정 비즈니스 로직이 여러 클라이언트 코드에서 호출되면 유지보수에 어려움을 겪을 수 있다. 따라서 다형성을 이용해 null 처리를 함으로써 변경으로 인한 파급효과를 줄이는 데 큰 도움이 될 수 있다고 생각한다.

해결하려 하지말고 공감해주자.

노력의천재 — Sun, 28 Aug 2022 23:19:23 +0900

나의 성격을 돌아봤을 때 누군가가 나에게 고민이나 우울했던 일상에 대해 털어놓으면 과몰입하여 이를 해결해주려고 하는 성향이 강하다는 것을 알게됐다. 나 스스로는 그것이 힘들다고 생각하지 않았는데, 어쩌면 내가 모르는 사이에 이에 몰입하여 스트레스를 받고, 나의 몸이 병들어 가고 있을지도 모른다는 것을 오늘 깨달았다. 앞으로는 이런 상황이 나에게 발생했을 때 해당 문제를 해결하려 하지말고 적당히, 나에게 영향이 가지 않을 정도로 공감해주는 선에서 끝내야겠다. 나 스스로를 책임지기도 어려운 촉박한 세상에서 내가 그 사람의 인생을 책임져줄게 아니라면 말이다.

[WEB] 쿠키(Cookie)와 세션(Session)의 개념 및 차이점

노력의천재 — Tue, 23 Aug 2022 18:11:24 +0900

개요

웹을 공부하는 사람이라면 쿠키(Cookie)와 세션(Session)에 대해 들어봤을 것이라고 확신한다. 이는 웹에서 굉장히 중요한 개념 중 하나이므로, 각각의 개념이 무엇인지, 차이점은 무엇인지 이해해보자.

HTTP 통신의 탄생

쿠키와 세션에 대해 알아보기전에 간단하게 HTTP 통신이 왜 나오게 됐는지, 이러한 HTTP의 어떠한 특성에 의해 쿠키와 세션이라는 개념이 나오게 됐는지 알아볼 필요가 있다.

소켓 통신

소켓(Socket)이란 네트워크상에서 서버와 클라이언트 두개의 프로그램이 특정 포트를 통해 양방향 통신이 가능하도록 만들어주는 소프트웨어 장치를 의미한다.

위의 그림에서 A와 C, B와 C가 서로 통신하기 위해서는 OS에서 제공하는 소켓이 필요하다. 예를들어 A가 5000번 포트로 연결 용도로 열린 C의 소켓에 연결한다. A가 C의 5000번 포트에 연결이 성공하면, 무작위 포트번호로(위의 예제에서는 5001번) 새로운 소켓을 만들고, 5000번 포트는 연결이 끊긴다. 이때 5000번 포트는 다른 사용자의 연결 요청을 계속 받기 위해서 새로운 포트와의 통신이 멀티 스레드를 통해 이루어진다.

소켓 통신의 장점은 연결이 계속 지속된다는 장점을 가지고 있지만, 연결이 늘어날수록 부하가 커진다는 단점이 존재한다. 이러한 단점을 해결하기 위해서 HTTP 통신 개념이 탄생하게 된다.

HTTP 통신

예를들어 A가 C와 통신하기 위해서 80포트로 a.html 파일을 요청하면, 소켓 통신처럼 C가 새로운 스레드를 생성하는 것이 아니라, 바로 요청에 맞게 a.html 파일을 찾아서 응답하고, 연결이 끊긴다.

즉 HTTP 통신은 클라이언트가 요청을 한 후 응답을 받으면 그 연결을 끊어 버리는 connectionless한 특징과 연결을 끊는 순간 클라이언트와 서버의 통신이 끝나며 상태 정보는 유지하지 않는 stateless한 특징을 가지고 있다. 쿠키와 세션 개념은 HTTP의 connectionless, stateless 두가지 특징을 해결하기 위해서 등장한다.

쿠키(Cookie)

쿠키의 개념

쿠키는 클라이언트(웹 브라우저) 로컬에 저장되는 key, value 로 이루어진 작은 데이터 파일
사용자 인증이 유효한 시간을 명시할 수 있으며, 유효 시간이 정해지면 브라우저가 종료되어도 인증 유지
쿠키는 클라이언트의 상태 정보를 로컬에 저장했다가 참조
클라이언트에 300개까지 쿠키 저장 가능, 하나의 도메인당 20개의 값만 가질 수 있음, 하나의 쿠키 값은 4KB까지 저장 가능
응답 헤더에 Set-Cookie 속성을 사용하면 클라이언트에 쿠키를 만들 수 있음
쿠키는 사용자가 따로 요청하지 않아도 브라우저가 요청 시에 요청 헤더를 넣어서 자동으로 서버에 요청

쿠키의 헤더 요소

Name : 각각의 쿠키를 구별하는 데 사용되는 이름
Value : 쿠키의 이름과 관련된 값
Domain : 쿠키를 전송할 도메인
Path : 쿠키를 전송할 요청 경로
Expires : 쿠키의 유지시간
Max-Age : 쿠키 수명을 알려줄 수 있음
Size : 쿠키의 크기(byte)
HttpOnly : 자바스크립트에서 쿠키에 접근할 수 없음
Secure : https에서만 쿠키가 전송
SameSite : 요청을 보내는 도메인이 같은 곳인지 확인
Priority : 쿠키 용량이 초과되어 일부를 삭제 해야할 때, 우선순위를 고려

세션(Session)

세션의 개념

세션은 쿠키를 기반하고 있지만, 사용자 정보 파일을 웹 브라우저에 저장하는 쿠키와 달리 세션은 서버 측에서 관리
서버에서는 클라이언트를 구분하기 위해 sessionid를 부여하며 웹 브라우저가 서버에 접속해서 브라우저를 종료할 때까지 인증상태를 유지
물론 접속 시간에 제한을 두어 일정 시간 응답이 없다면 정보가 유지되지 않게 설정이 가능
사용자에 대한 정보를 서버에 두기 때문에 쿠키보다 보안에 좋지만, 사용자가 많아질수록 서버 메모리를 많이 차지
즉 동접자 수가 많은 웹 사이트인 경우 서버에 과부하를 주게 되므로 성능 저하의 요인
클라이언트가 Request를 보내면, 해당 서버의 엔진이 클라이언트에게 유일한 ID를 부여 (세션ID)

세션의 특징

각 클라이언트에게 고유 ID를 부여
세션 ID로 클라이언트를 구분해서 클라이언트의 요구에 맞는 서비스를 제공
보안 면에서 쿠키보다 우수
사용자가 많아질수록 서버 메모리를 많이 차지하게 됨

쿠키와 세션 프로세스

쿠키와 세션을 이용한 HTTP 요청-응답 프로세스

쿠키와 세션 차이

위치

쿠키는 클라이언트에 저장되고, 세션은 서버쪽에 저장된다.

속도

세션의 경우 서버의 처리가 필요하기 때문에 쿠키보다 상대적으로 요청 처리 속도가 느리다.

보안

쿠키는 클라이언트 로컬에 저장되기 때문에 변질되거나 request에서 스니핑 당할 우려가 있어서 보안에 취약하지만 세션은 쿠키를 이용해서 sessionid만 저장하고, 이로 구분하여 서버에서 처리하기 때문에 비교적 보안성이 좋다.

생명 주기(life cycle)

쿠키도 만료시간이 있지만 파일로 저장되기 때문에 브라우저를 종료해도 계속해서 정보가 남아 있을 수 있다. 또한 만료기간을 넉넉하게 잡아두면 쿠키 삭제를 할 때 까지 유지될 수도 있다. 반면에 세션도 만료시간을 정할 수 있지만, 브라우저가 종료되면 만료시간에 상관없이 삭제된다.

반년차 신입의 회사 생활 후기 (feat. 짧음, no성의)

노력의천재 — Thu, 21 Jul 2022 01:32:29 +0900

※ 의식의 흐름대로 적어가는 후기글이기에 두서가 없다는 점 양해드립니다.

2022년 1월 10일에 신입 개발자로 첫 입사를 하고나서 벌써 반년이라는 시간이 지났다. 시간 짱 빠르네;;; 내일 모레면 곧 서른이다 ㅠ,ㅠ 어른이 하고싶다.

아무튼 나는 현재 회사 생활에 나름... 만족하고 있다. 각자 생각하는 좋은 회사의 기준이 다르겠지만, 내 기준에서 좋은 회사란 다음과 같다.

정해진 규칙 안에서 자유로운 의사결정을 할 수 있는 회사
야근이 잦지 않아 나의 자기계발 시간을 보장 받을 수 있는 회사
팀원들끼리 서로 존중하고 으쌰으쌰 하는 회사
급여 및 복지가 좋은 회사
...

고맙게도 현재 내가 다니고 있는 회사는 위의 조건을 대부분 만족하여(?) 만족스러운 회사 생활을 하고있다. 제일 큰 흠이 있다면 통근이 빡시다는 것인데,,, 원래라면 삼성역쪽에서 근무를 해야하지만, 우리 팀은 다른 곳으로 유배(?)와있다. 그래서 나의 근무지로 출근하려면 거의 철인 3종경기 맞먹는 과정을 거쳐야한다. 그러나 요즘은 주 2~3일 재택 근무를 하고 있어서 조금은 살 맛 난다.

무엇보다 좋은 팀원을 만난 것에 너무 감사하다.. 모두 다 성격도 좋으시고, 우리 팀이 운영하고 있는 서비스에 대한 업무들을 꿰차고 있으셔서 많은 도움을 받고있는 중이다. 또한, 신입 치고는 비중있는 업무를 주시는 것 같은데... (서비스 운영을 셋이서하니 일손이 모자라서 그런 것 같다.)

그렇다면 반년동안 회사 생활을 하며 이뤄낸 성과는 뭐가 있을까? 먼저 Google Cloud Academy에 참여한 사내 직원들 중 우수 학습자로 선발되었다. GCA는 구글 코리아와 우리 회사가 협약을 맺어 진행한 교육 프로그램인데, 생각보다 다른 직원들이 프로그램에 참여를 적게해서 얻은 성과인 것 같다. 내가 잘 했다기 보다는 그냥 성실하게 프로그램에 참여한 결과이다. (기념품으로 굿즈 준다고 하는데 기대중) 또한, 회사의 교육 복지를 이용하여 개발 서적과 인프런 강의를 통해 학습한 내용을 실무 코드에 적용해보고 있는데, 이 과정에서 주변의 똑똑이 친구들보다는 비록 느리지만, 스스로 조금씩 성장해가는게 보여서 기분이 좋다 ㅎㅎ

작성하다보니 회사의 좋은점만 남긴 것 같은데, 1년차 후기글에는 회사 생활을 하며 아쉬웠던 점을 남겨봐야겠다. 내일 출근하는 날이라서 이 정도만 남겨야지

[백준/BOJ] 14620번 꽃길

노력의천재 — Tue, 21 Jun 2022 00:35:00 +0900

https://www.acmicpc.net/problem/14620

14620번: 꽃길

2017년 4월 5일 식목일을 맞이한 진아는 나무를 심는 대신 하이테크관 앞 화단에 꽃을 심어 등교할 때 마다 꽃길을 걷고 싶었다. 진아가 가진 꽃의 씨앗은 꽃을 심고나면 정확히 1년후에 꽃이 피므

www.acmicpc.net

쉬운 DFS 문제였다. 씨앗을 3개 심을 수 있는 모든 경우의 수를 구한 후, 해당 케이스가 꽃이 피어날 수 있는지를 확인하면 된다. 배열을 여러 개 두면 쉽게 구현할 수 있다. (코드 참고)

#include<bits/stdc++.h>
#define f first
#define s second
#define lp1(i, x, n) for(int i = x; i <= n; i++)
using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int t, n, m, h, k, sx, sy, ex, ey, x, y, z, answer = 2147000000, L, R, _x1, _x2, _y1, _y2, flag, sum;
int board[11][11], visited[11][11], bloomed[11][11]; // 가격, 씨앗, 꽃잎의 위치를 저장할 배열
vector<pair<int, int>> v; // 씨앗을 3개 심은 위치를 저장

// 꽃이 펼 수 있는지 확인
bool check() {
	int tmp_sum = 0;
	memset(bloomed, 0, sizeof(bloomed));
	for(int i = 0; i < v.size(); i++) {
		int x = v[i].f;
		int y = v[i].s;
 		tmp_sum += board[x][y];
		for(int j = 0; j < 4; j++) {
			int nx = x + dx[j];
			int ny = y + dy[j];
			if(visited[nx][ny] || bloomed[nx][ny]) return false;
			bloomed[nx][ny] = 1;
			tmp_sum += board[nx][ny]; 
		}
		if(tmp_sum >= answer) return false;
	}
	
	sum = tmp_sum;
	return true;
}

// 씨앗을 3개 심는 경우의 수 구하기
void DFS(int cnt) {
	if(cnt == 3) {
		if(check()) answer = min(answer, sum);
		return;
	}
	
    // 범위를 벗어나지 않는 곳에서 시작/끝 지점을 잡았다.
	for(int i = 1; i < n - 1; i++) {
		for(int j = 1; j < n - 1; j++) {
			if(visited[i][j] == 0) {
				visited[i][j] = 1;
				v.push_back({ i, j });
				DFS(cnt + 1);
				visited[i][j] = 0;
				v.pop_back();
			}	
		}
	}
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n;
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < n; j++) {
			cin >> board[i][j];
		}
	}
	
	DFS(0);
	cout << answer;
}

[백준/BOJ] 9934번 완전 이진 트리

노력의천재 — Thu, 9 Jun 2022 17:18:00 +0900

https://www.acmicpc.net/problem/9934

9934번: 완전 이진 트리

상근이는 슬로베니아의 도시 Donji Andrijevci를 여행하고 있다. 이 도시의 도로는 깊이가 K인 완전 이진 트리를 이루고 있다. 깊이가 K인 완전 이진 트리는 총 2K-1개의 노드로 이루어져 있다. (아래

www.acmicpc.net

중위 탐색의 결과를 완전 이진 트리로 바꿔야 하는 문제다.

특정 depth까지 left와 right을 설정해 루트 노드를 탐색하는 방법을 반복하면서 문제를 해결하는데, 이분 탐색을 재귀로 구현하는 것과 비슷하다.

#include<bits/stdc++.h>
#define f first
#define s second
#define lp1(i, x, n) for(int i = x; i <= n; i++)
using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int t, n, m, k, sx, sy, ex, ey, x, y, z, answer, L, R, _x1, _x2, _y1, _y2, flag;
int a[2000], visited[2000];
vector<int> res[10];

void DFS(int depth, int left, int right) {
	if(depth >= n) return;
	int root = (left + right) / 2;
	if((root >= 0 && root < k) && !visited[root]) {
		visited[root] = 1;
		res[depth].push_back(a[root]);
		DFS(depth + 1, left, root - 1);
		DFS(depth + 1, root + 1, right);	
	}
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n;
	k = (1 << n) - 1;
	for(int i = 0; i < k; i++) {
		cin >> a[i];
	}
    
	if(n == 1) {
		cout << a[0];
		return 0;
	}
    
	DFS(0, 0, k - 1);
    
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < res[i].size(); j++) {
			cout << res[i][j] << " ";
		}
		cout << "\n";
	}
}

[백준/BOJ] 2529번 부등호

노력의천재 — Sun, 29 May 2022 21:55:33 +0900

https://www.acmicpc.net/problem/2529

2529번: 부등호

여러분은 제시된 부등호 관계를 만족하는 k+1 자리의 최대, 최소 정수를 첫째 줄과 둘째 줄에 각각 출력해야 한다. 단 아래 예(1)과 같이 첫 자리가 0인 경우도 정수에 포함되어야 한다. 모든 입력

www.acmicpc.net

시간복잡도가 9! 이므로 완전탐색으로 충분히 해결할 수 있다. 따라서 모든 순열을 구한 후, 조건에 만족하는 처음 값(최소값)과 마지막 값(최대값)을 출력하였다.

#include<bits/stdc++.h>
#define f first
#define s second
#define lp1(i, x, n) for(int i = x; i <= n; i++)
using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int t, n, m, k, sx, sy, ex, ey, x, y, z, answer, L, R, _x1, _x2, _y1, _y2, flag;
char op[15];
int visited[15], selected[15];
vector<string> res;

void DFS(int idx, int cnt) {
	if(cnt == n + 1) {
		bool flag = true;
		for(int i = 0; i < n; i++) {
			if(op[i] == '<') {
				if(selected[i] > selected[i + 1]) {
					flag = false;
					break;
				}
			} else if(op[i] == '>') {
				if(selected[i] < selected[i + 1]) {
					flag = false;
					break;
				}
			}
		}
		if(flag) {
			string str = "";
			for(int i = 0; i <= n; i++) {
				str += to_string(selected[i]);
			}
			res.push_back(str);
		}
		return;
	}
	
	for(int i = 0; i < 10; i++) {
		if(visited[i] == 0) {
			selected[cnt] = i;
			visited[i] = 1;
			DFS(i, cnt + 1);
			visited[i] = 0;
		}
	}
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n;
	for(int i = 0; i < n; i++) {
		cin >> op[i];
	}
	DFS(0, 0);
	cout << res.back() << "\n" << res.front();
}

[백준/BOJ] 14497번 주난의 난

노력의천재 — Sun, 22 May 2022 16:38:49 +0900

https://www.acmicpc.net/problem/14497

14497번: 주난의 난(難)

주난이는 크게 화가 났다. 책상 서랍 안에 몰래 먹으려고 숨겨둔 초코바가 사라졌기 때문이다. 주난이는 미쳐 날뛰기 시작했다. 사실, 진짜로 뛰기 시작했다. ‘쿵... 쿵...’ 주난이는 점프의 파

www.acmicpc.net

초기 코드

#include<bits/stdc++.h>
#define f first
#define s second
#define lp1(i, x, n) for(int i = x; i <= n; i++)

using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

struct Info {
	int x, y, cnt;
};

int t, n, m, k, sx, sy, ex, ey, x, y, z, answer = -1, L, R, _x1, _x2, _y1, _y2;
char area[301][301];
int visited[301][301];
	
int BFS() {
	queue<Info> q;
	q.push({ _x1, _y1, 0 });
	visited[_x1][_y1] = 1;
	
	while(!q.empty()) {
		int x = q.front().x;	
		int y = q.front().y;
		int cnt = q.front().cnt;
		q.pop();
//		cout << x << " " << y << " " << cnt << "\n";
		visited[x][y] = 1;
		if(answer != -1 && answer < cnt) break;
		if((answer == -1 || answer > cnt) && (x == _x2 && y == _y2)) answer = cnt; 
		
		for(int i = 0; i < 4; i++) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if(nx < 0 || nx >= n || ny < 0 || ny >= m || visited[nx][ny] == 1) continue;
			if(area[nx][ny] == '0') {
				q.push({ nx, ny, cnt });
			} else {
				q.push({ nx, ny, cnt + 1 });
			}
		}
	}
	
	return answer;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n >> m >> _x1 >> _y1 >> _x2 >> _y2;
	_x1--, _y1--, _x2--, _y2--;
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < m; j++) {
			cin >> area[i][j];		
		}
	}
	
//	for(int i = 0; i < n; i++) {
//		for(int j = 0; j < m; j++) {
//			cout << area[i][j] << " ";
//		}
//		cout << "\n";
//	}

	cout << BFS();
}

BFS 탐색을 하면서 '0'을 만나면 cnt를 증가시키지 않고 큐 탐색, '1'이나 '#'을 만나면 cnt를 1 증가시켜 큐 탐색을 하도록 구현하였으나, 메모리 초과 발생 (시간이 지남에 따라 큐에 들어가는 횟수가 많아져 메모리 초과가 발생하는 듯하다.)

따라서 2차원 배열 두개를 선언하여, 시간에 따라 '1'을 최초로 만났을 때의 상태를 기록하여 큐에 들어가는 횟수를 줄여야 한다.

풀이 코드

#include<bits/stdc++.h>
#define f first
#define s second
#define lp1(i, x, n) for(int i = x; i <= n; i++)

using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

struct Info {
	int x, y, cnt;
};

int t, n, m, k, sx, sy, ex, ey, x, y, z, answer = 1, L, R, _x1, _x2, _y1, _y2;
char area[301][301], cpy[301][301]; // 현재 배열, 탐색 후 배열
int visited[301][301];
	
bool BFS() {
	queue<pair<int, int>> q;
	q.push({ _x1, _y1 });
	visited[_x1][_y1] = 1;
	
	while(!q.empty()) {
		tie(x, y) = q.front();
		q.pop();
//		cout << x << " " << y << " " << cnt << "\n";
		if(x == _x2 &&  y == _y2) {
			
		}
		
		for(int i = 0; i < 4; i++) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if(nx < 0 || nx >= n || ny < 0 || ny >= m || visited[nx][ny] == 1) continue;
			visited[nx][ny] = 1;
			if(area[nx][ny] == '0') q.push({ nx, ny });
			else if(area[nx][ny] == '1') cpy[nx][ny] = '0';
			else if(area[nx][ny] == '#') return true;
		}
	}
	
	return false;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n >> m >> _x1 >> _y1 >> _x2 >> _y2;
	_x1--, _y1--, _x2--, _y2--;
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < m; j++) {
			cin >> area[i][j];		
		}
	}

	while(1) {
		memset(visited, 0, sizeof(visited));
		memcpy(cpy, area, sizeof(area));
//		for(int i = 0; i < n; i++) {
//			for(int j = 0; j < m; j++) {
//				cout << area[i][j] << " ";
//			}
//			cout << "\n";
//		}
//		cout << "\n";
		if(BFS()) break;
		memcpy(area, cpy, sizeof(cpy));
//		for(int i = 0; i < n; i++) {
//			for(int j = 0; j < m; j++) {
//				cout << area[i][j] << " ";
//			}
//			cout << "\n";
//		}
//		cout << "\n";
		answer++;
	}
	
	cout << answer;
}

[백준/BOJ] 2589번 보물섬

노력의천재 — Thu, 5 May 2022 02:05:11 +0900

https://www.acmicpc.net/problem/2589

2589번: 보물섬

첫째 줄에는 보물 지도의 세로의 크기와 가로의 크기가 빈칸을 사이에 두고 주어진다. 이어 L과 W로 표시된 보물 지도가 아래의 예와 같이 주어지며, 각 문자 사이에는 빈 칸이 없다. 보물 지도의

www.acmicpc.net

처음엔 다음과 같이 접근하였다.

1. 지도에서 2개의 육지를 뽑는 모든 조합을 구한다.

2. 조합에서 두 육지 사이의 거리가 가장 긴 경우를 DFS로 구한다.

3. DFS에서 선택된 2개의 육지 사이에 도달하는 최단 시간을 BFS로 구한다.

그러나 위와 같은 방법으로 문제를 접근하면 250C2 * 50 * 50 * 4 = 311,250,000로 시간초과 발생 (~~멍청하게 50C2로 계산해서 망했다 ㅋ~~)

따라서 복잡하게 생각할 필요없이, 2중 for문을 돌리며 육지를 만날때마다 BFS를 통해 모든 육지로의 거리를 구하고, 이 중에서 최대값을 구하면 된다.

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int t, n, m, k, x, y, answer;
char area[51][51]; 
int visited[51][51];

int BFS(int sx, int sy) {
	int res = 0;
	memset(visited, -1, sizeof(visited));
	queue<pair<int, int>> q;
	q.push({ sx, sy });
	visited[sx][sy] = 0;
	
	while(!q.empty()) {
		tie(x, y) = q.front();
		q.pop();
		for(int i = 0; i < 4; i++) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if(nx < 0 || nx >= n || ny < 0 || ny >= m || area[nx][ny] == 'W' || visited[nx][ny] != -1) continue;
			q.push({ nx, ny });
			visited[nx][ny] = visited[x][y] + 1;
			res = max(res, visited[nx][ny]);
		}
	}
	
	return res;
}


int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

	cin >> n >> m; 
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < m; j++) {
			cin >> area[i][j];
		}
	}

	for(int i = 0; i < n; i++) {
		for(int j = 0; j < m; j++) {
			if(area[i][j] == 'L') answer = max(answer, BFS(i, j));
		}
	}

	cout << answer;
}

[백준/BOJ] 17825번 주사위 윷놀이

노력의천재 — Tue, 3 May 2022 00:41:46 +0900

https://www.acmicpc.net/problem/17825

17825번: 주사위 윷놀이

주사위 윷놀이는 다음과 같은 게임판에서 하는 게임이다. 처음에는 시작 칸에 말 4개가 있다. 말은 게임판에 그려진 화살표의 방향대로만 이동할 수 있다. 말이 파란색 칸에서 이동을 시작하면

www.acmicpc.net

빡센 완탐문제(짱 어렵당), 완벽히 풀 수 있을 때까지 반복해볼 것

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int t, n, m, k, sx, sy, ex, ey, x, y, answer, root;
// a : 주사위 입력값, mal : 말의 위치 저장(변환된 위치), v : 트리의 노드 위치를 변환하여 저장
int a[11], mal[4], v[101];
vector<int> adj[101];

// 주사위 입력값만큼 말 이동하기
int BFS(int here, int cnt) {
	if(here == 100) return 100;
	if(adj[here].size() > 1) {
		here = adj[here][1];
		cnt--;
	}
	if(cnt > 0) {
		queue<int> q;
		q.push(here);
		int there;
		while(!q.empty()) {
			int x = q.front();
			q.pop();
			there = adj[x][0];
			q.push(there);
			if(there == 100) break;
			cnt--;
			if(cnt == 0) break;
		}
		return there;
	}
	
	return here;
}

// 특정 위치에 말이 있는지 확인
bool isMal(int mal_idx, int idx) {
	if(mal_idx == 100) return false;
	for(int i = 0; i < 4; i++) {
		if(i == idx) continue;
		if(mal[i] == mal_idx) return true;
	}
	return false;
}

// 주사위 이동에 따라 생성되는 점수의 모든 경우를 구하기
int DFS(int here) {
	if(here == 10) return 0;
	int res = 0;
	for(int i = 0; i < 4; i++) {
		int temp_idx = mal[i];
		int mal_idx = BFS(temp_idx, a[here]);
		if(isMal(mal_idx, i)) continue;
		mal[i] = mal_idx;
		res = max(res, DFS(here + 1) + v[mal_idx]);
		mal[i] = temp_idx;
	}
	return res;
}

// 인접리스트로 트리 생성
void init() {
	v[1] = 2, v[2] = 4, v[3] = 6, v[4] = 8, v[5] = 10;
	v[6] = 12, v[7] = 14, v[8] = 16, v[9] = 18, v[10] = 20;
	v[11] = 22, v[12] = 24, v[13] = 26, v[14] = 28, v[15] = 30;
	v[16] = 32, v[17] = 34, v[18] = 36, v[19] = 38, v[20] = 40;
	v[21] = 13, v[22] = 16, v[23] = 19, v[24] = 22, v[25] = 24;
	v[26] = 28, v[27] = 27, v[28] = 26, v[29] = 25, v[30] = 30, v[31] = 35;
	
	// 2 ~ 40
	for(int i = 0; i < 20; i++) {
		adj[i].push_back(i + 1);
	} 
	
	// 10 ~ 25
	adj[5].push_back(21);
	adj[21].push_back(22);
	adj[22].push_back(23);
	adj[23].push_back(29);
	
	// 20 ~ 25
	adj[10].push_back(24);
	adj[24].push_back(25);
	adj[25].push_back(29);
	
	// 30 ~ 25
	adj[15].push_back(26);
	adj[26].push_back(27);
	adj[27].push_back(28);
	adj[28].push_back(29);
	
	// 25 ~ 40
	adj[29].push_back(30);
	adj[30].push_back(31);
	adj[31].push_back(20);
	adj[20].push_back(100);
}


int main() {
	freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	init();
	for(int i = 0; i < 10; i++) {
		cin >> a[i];
	}
	
	cout << DFS(0);
}

[백준/BOJ] 1189번 컴백홈

노력의천재 — Sat, 30 Apr 2022 01:11:37 +0900

https://www.acmicpc.net/problem/1189

1189번: 컴백홈

첫 줄에 정수 R(1 ≤ R ≤ 5), C(1 ≤ C ≤ 5), K(1 ≤ K ≤ R×C)가 공백으로 구분되어 주어진다. 두 번째부터 R+1번째 줄까지는 R×C 맵의 정보를 나타내는 '.'과 'T'로 구성된 길이가 C인 문자열이 주어진다

www.acmicpc.net

백트래킹을 이용하여 경로의 모든 경우의 수를 구한 후, 거리가 K인 개수를 구하는 문제이다.

(DFS 구현시, 반환값이 있는 형태로 만드는 연습이 필요한 것 같다.)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int n, m, k;
char area[11][11];
int visited[11][11];

int DFS(int x, int y, int d) {
	if(x == 0 && y == m - 1) {
		if(k == d) return 1;
		return 0;
	}
	
	int ret = 0;
	for(int i = 0; i < 4; i++) {
		int nx = x + dx[i];
		int ny = y + dy[i];
		if(nx < 0 || nx >= n || ny < 0 || ny >= m || area[nx][ny] == 'T' || visited[nx][ny] == 1) continue;
		visited[nx][ny] = 1;
		ret += DFS(nx, ny, d + 1);
		visited[nx][ny] = 0;
	}
	
	return ret;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n >> m >> k;
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < m; j++) {
			cin >> area[i][j];
		}
	}
	
	visited[n - 1][0] = 1;
	cout << DFS(n - 1, 0, 1);
}

#include<bits/stdc++.h>
#define f first
#define s second
#define lp1(i, x, n) for(int i = x; i <= n; i++)
using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int t, n, m, h, k, r, c, sx, sy, ex, ey, x, y, z, answer = 2147000000, L, R, flag, sum;
char board[11][11];
int visited[11][11], res[31];

void DFS(int _x1, int _y1, int _x2, int _y2, int cnt) {
    if (_x1 == _x2 && _y1 == _y2) {
        res[cnt]++;
        return;
    }
    
    for(int i = 0; i < 4; i++) {
        int nx = _x1 + dx[i];
        int ny = _y1 + dy[i];
        if(nx < 0 || nx >= r || ny < 0 || ny >= c) continue;
        if(visited[nx][ny] || board[nx][ny] == 'T') continue;
        visited[nx][ny] = 1;
        DFS(nx, ny, _x2, _y2, cnt + 1);
        visited[nx][ny] = 0;
    }
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> r >> c >> k;
    for(int i = 0; i < r; i++) {
        for(int j = 0; j < c; j++) {
            cin >> board[i][j];
        }
    }
    sx = r - 1, sy = 0;
    ex = 0, ey = c - 1;
    if(board[sx][sy] == 'T' || board[ex][ey] == 'T') {
        cout << "0";
        return 0;
    }
    visited[sx][sy] = 1;
    DFS(sx, sy, ex, ey, 1);
    cout << res[k];
}

[백준/BOJ] 1068번 트리

노력의천재 — Mon, 25 Apr 2022 23:13:53 +0900

https://www.acmicpc.net/problem/1068

1068번: 트리

첫째 줄에 트리의 노드의 개수 N이 주어진다. N은 50보다 작거나 같은 자연수이다. 둘째 줄에는 0번 노드부터 N-1번 노드까지, 각 노드의 부모가 주어진다. 만약 부모가 없다면 (루트) -1이 주어진다

www.acmicpc.net

인접 리스트를 이용해 트리를 구현한 후, DFS 탐색을 하면서 리프노드에 도달하면 1을 리턴하고, 리프 노드의 수를 각 노드를 거쳐 루트까지 누적해가면 된다. 이때, 루트 노드를 제거하는 경우를 예외처리 해줘야 한다.

[백준/BOJ] 2636번 치즈

노력의천재 — Sun, 24 Apr 2022 18:00:32 +0900

https://www.acmicpc.net/problem/2636

2636번: 치즈

아래 <그림 1>과 같이 정사각형 칸들로 이루어진 사각형 모양의 판이 있고, 그 위에 얇은 치즈(회색으로 표시된 부분)가 놓여 있다. 판의 가장자리(<그림 1>에서 네모 칸에 X친 부분)에는 치즈가 놓

www.acmicpc.net

(0,0)부터 차례대로 BFS 탐색을 한다. 탐색 도중 값이 1인 지역을 만난다면, 해당 지역은 가장 바깥부분을 의미한다. 따라서 해당 지역을 0으로 바꿔주고, 큐에는 넣지 않는다. 이렇게 하면 BFS 탐색을 할 때마다, 치즈 안쪽의 구멍을 신경쓰지 않아도 공기에 노출된 겉표면만을 제거할 수 있다.

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int n, m, answer, x, y;
int board[101][101];
int visited[101][101];

int BFS() {
	int cnt = 0;
	queue<pair<int, int>> q;
	q.push({ 0, 0 });
	visited[0][0] = 1;
	
	while(!q.empty()) {
		tie(x, y) = q.front();
		q.pop();
		
		for(int i = 0; i < 4; i++) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if(nx < 0 || nx >= n || ny < 0 || ny >= m || visited[nx][ny]) continue;
			visited[nx][ny] = 1;
			if(board[nx][ny] == 0) {
				q.push({ nx, ny });
			} else {
				cnt++;
				board[nx][ny] = 0;
			}
		}
	}
	
	if(cnt > 0) answer = cnt;
	return cnt > 0;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> n >> m;
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < m; j++) {
			cin >> board[i][j];
		}
	}
	
	int time = 0;
	while(BFS()) {
		memset(visited, 0, sizeof(visited));
		time++;
	}
	
	cout << time << "\n" << answer;
}

[C/C++] STL pair, tuple 사용법

노력의천재 — Tue, 15 Mar 2022 22:45:55 +0900

C++에 튜플이 있는지 첨 알았다!!! WOW

#include<bits/stdc++.h>
using namespace std;

pair<int, int> p;
tuple<int, int, int> t;
int a, b, c;

int main() {
	// 원래 방법 
	p = make_pair(1, 2);
	t = make_tuple(1, 2, 3);
	
	a = p.first;
	b = p.second;
	cout << a << " " << b << "\n";
	
	a = get<0>(t);
	b = get<1>(t);
	c = get<2>(t);
	cout << a << " " << b << " " << c << "\n";
	
	// tie 함수를 이용하는 방법 
	p = {1, 2};
	t = make_tuple(1, 2, 3);
	
	tie(a, b) = p;
	cout << a << " " << b << "\n";
	 
	tie(a, b, c) = t;
	cout << a << " " << b << " " << c << "\n";
}

[Python] 파이썬 문법 정리

노력의천재 — Sat, 22 Jan 2022 23:44:36 +0900

자료형

# 지수 표현 방식
a = 1e9
print(a)

a = int(1e9)
print(a)

a = 75.25e1
print(a)

a = 3954e-3
print(a)

# IEEE754 표준에서는 실수형을 저장하기 위해 4 혹은 8바이트의 고정된 크기의 메모리를 할당
# 따라서 실수 정보를 표현햐는 정확도에 한계가 존재
a = 0.3 + 0.6
print(a)

if a == 0.9:
  print(True)
else:
  print(False)

# 따라서 round 함수를 이용해 반올림을 해준다.
a = 0.3 + 0.6
if round(a, 2) == 0.9: # 소수 셋째 자리에서 반올림
  print(True)
else:
  print(False)

# 파이썬에서 / 연산자는 나눠진 결과를 실수형으로 반환한다.
# 파이썬에는 몫을 얻기 위해 // 연산자를 사용한다.
# 이외에도 ** 연산자를 이용해 거듭 제곱과 제곱근을 구할 수 있다.
a = 5
b = 3

# 나누기
print(a / b)

# 나머지
print(a % b)

# 몫
print(a // b)

# 거듭 제곱
print(a ** b)

# 제곱근
print(a ** 0.5)

실행 결과
1000000000.0
1000000000
752.5
3.954
0.8999999999999999
False
True
1.6666666666666667
2
1
125
2.23606797749979

리스트

# 리스트
# 배열 혹은 테이블이라고 부르기도 한다.
# 배열의 기능 및 연결 리스트와 유사한 기능을 지원한다.

# 직접 데이터를 넣어 초기화
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a)

# 네 번째 원소 출력
print(a[3])

# 크기가 n이고, 모든 값이 0인 1차원 리스트 초기화
n = 10
a = [0] * n
print(a)

# 인덱싱
# 인덱스의 값을 입력하여 리스트의 특정 원소에 접근할 수 있다.
# 음의 정수를 사용하면 거꾸로 탐색하게 된다.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 여덟 번째 원소만 출력
print(a[7])

# 뒤에서 첫 번째 원소 출력
print(a[-1])

# 뒤에서 세 번째 원소 출력
print(a[-3])

# 네 번째 원소 값 변경
a[3] = 7
print(a)

# 슬라이싱
# 리스트에서 연속적인 위치를 갖는 원소를 가져올 수 있다.
# 끝 인덱스는 실제 인덱스보다 1을 더 크게 설정한다.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 두 번째 원소부터 네 번째 원소까지
print(a[1 : 4])

# 리스트 컴프리헨션
# 대괄호 안에 조건문과 반복문을 이용해 리스트를 초기화할 수 있다.

# 0부터 9까지의 수를 포함하는 리스트
a = [i for i in range(10)]
print(a)

# 0부터 19까지의 수 중에서 홀수만 포함하는 리스트
a = [i for i in range(20) if i % 2 == 1]
print(a)

# 1부터 9까지의 수들의 제곱 값을 포함하는 리스트
a = [i * i for i in range(1, 10)]
print(a)

# n x m 크기의 2차원 리스트 초기화
# n번 반복될 때 마다 길이가 m인 리스트가 생성된다.
n = 4
m = 3
a = [[0] * m for _ in range(n)] # _ : 반복을 위한 변수의 값 무시
print(a)

# 잘못된 방법
a = [[0] * m] * n
print(a)

a[1][1] = 5
print(a)

실행 결과
[1, 2, 3, 4, 5, 6, 7, 8, 9]
4
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
8
9
7
[1, 2, 3, 7, 5, 6, 7, 8, 9]
[2, 3, 4]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 5, 0], [0, 5, 0], [0, 5, 0], [0, 5, 0]]

리스트 관련 메서드

a = [1, 4, 3]
print("기본 리스트 : ", a)

# 리스트에 원소 삽입
a.append(2)
print("삽입 : ", a)

# 오름차순 정렬
a.sort()
print("오름차순 정렬 : ", a)

# 내림차순 정렬
a.sort(reverse = True)
print("내림차순 정렬 : ", a)

# 리스트 원소 뒤집기
a.reverse()
print("원소 뒤집기 : ", a)

# 특정 인덱스에 데이터 추가
a.insert(2, 3)
print("인덱스 2에 3 추가 : ", a)

# 특정 값인 데이터 개수 세기
print("값이 3인 데이터 개수 : ", a.count(3))

# 특정 값 데이터 삭제
a.remove(1)
print("값이 1인 데이터 삭제 : ", a)

a = [1, 2, 3, 4, 5, 5, 5]
remove_set = {3, 5} 

# remove_set에 포함되지 않은 값만을 저장
result = [i for i in a if i not in remove_set]
print(result)

실행 결과
기본 리스트 :  [1, 4, 3]
삽입 :  [1, 4, 3, 2]
오름차순 정렬 :  [1, 2, 3, 4]
내림차순 정렬 :  [4, 3, 2, 1]
원소 뒤집기 :  [1, 2, 3, 4]
인덱스 2에 3 추가 :  [1, 2, 3, 3, 4]
값이 3인 데이터 개수 :  2
값이 1인 데이터 삭제 :  [2, 3, 3, 4]
[1, 2, 4]

문자열, 튜플

# 문자열
# "", ''를 이용하여 초기화한다.
# 전체 문자열을 ""로 구성하는 경우, 내부적으로 '',
# 전체 문자열을 ''로 구성하는 경우, 내부적으로 ""를 포함시킬 수 있다.

data = 'Hello World'
print(data)

data = "Don't you know \"Python\"?"
print(data)

# 문자열 연산 
# 덧셈(+)을 이용하면 문자열이 더해져 연결된다.
# 양의 정수와 곱하는 경우, 문자열이 그 값만큼 여러 번 더해진다.
# 인덱싱과 슬라이싱 가능, 그러나 특정 인덱스의 값을 변경할 수 없다. (Immutable)
a = "Hello"
b = "World"
print(a + " " + b)

a = "String"
print(a * 3)

a = "ABCDEF"
print(a[2 : 4])

# 튜플
# 리스트와 유사, 그러나 한 번 선언된 값을 변경할 수 없다.
# 리스트는 []를 이용하지만 튜플은 ()를 이용한다.
# 1. 서로 다른 성질의 데이터를 묶어서 관리할 때
# ex) 최단경로 알고리즘에서 (비용, 노드번호)의 형태로 튜플 자료형을 자주 사용한다.
# 2. 데이터의 나열을 해싱(Hashing)의 키 값으로 사용할 때
# ex) 튜플은 변경이 불가능하므로 키 값으로 사용될 수 있다.
# 3. 리스트보다 메모리를 효유적으로 사용해야 할 때
# ex) 튜플은 리스트에 비해 상대적으로 공간 효율적이다. (기능 제한적, 메모리를 적게 사용함)

a = (1, 2, 3, 4, 5, 6, 7, 8, 9)

# 네 번째 원소만 출력
print(a[3])

# 두 번째 원소부터 네 번째 원소까지 출력
print(a[1 : 4])

실행 결과
Hello World
Don't you know "Python"?
Hello World
StringStringString
CD
4
(2, 3, 4)

딕셔너리(사전), 집합

# 딕셔너리
# 키와 값의 쌍을 데이터로 가지는 자료형이다.
# 변경 불가능한(Immutable) 자료형을 키로 사용할 수 있다.
# 딕셔너리는 해시 테이블을 이용하므로, 데이터의 조회 및 수정은 O(1)이 소요된다.

data = dict()
data['사과'] = 'Apple'
data['바나나'] = 'Banana'
data['코코넛'] = 'Coconut'

print(data)

if '사과' in data:
  print("'사과'를 키로 가지는 데이터가 존재합니다.")

# 딕셔너리 관련 메서드
# keys() : 키 데이터만 따로 뽑아서 리스트로 이용한다.
# values() : 값 데이터만 따로 뽑아서 리스트로 이용한다. 

key_list = data.keys()
value_list = data.values()

print(key_list)
print(value_list)

# 각 키에 따른 값을 하나씩 출력
for key in key_list:
  print(data[key])

# 집합
# 중복을 허용하지 않고 순서가 없는 자료형이다.
# 리스트 혹은 문자열을 이용해 초기화할 수 있다 : set() 
# 혹은 {} 안에 각 원소를 ,로 구분하여 초기화할 수 있다.
# 데이터의 조회 및 수정은 O(1)이 소요된다.

data = set([1, 1, 1, 2, 3, 4, 4, 5])
print(data)

data = {1, 1, 1, 2, 3, 4, 4, 5}
print(data)

# 집합의 연산
# 합집합 : A에 속하거나 B에 속하는 원소로 이루어진 집합
# 교집합 : A에도 속하고 B에도 속하는 원소로 이루어진 집합
# 차집합 : A(B)의 원소 중에서 B(A)에 속하지 않는 원소로 이루어진 집합

a = set([1, 2, 3, 4, 5])
b = set([3, 4, 5, 6, 7])

# 합집합
print(a | b)

# 교집합
print(a & b)

# 차집합
print(a - b)
print(b - a)

# 집합 관련 메서드
data = set([1, 2, 3])
print(data)

# 새로운 원소 추가
data.add(4)
print(data)

# 새로운 원소 여러 개 추가
data.update([5, 6])
print(data)

# 특정한 값을 갖는 원소 삭제
data.remove(3)
print(data)

실행 결과
{'사과': 'Apple', '바나나': 'Banana', '코코넛': 'Coconut'}
'사과'를 키로 가지는 데이터가 존재합니다.
dict_keys(['사과', '바나나', '코코넛'])
dict_values(['Apple', 'Banana', 'Coconut'])
Apple
Banana
Coconut
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6, 7}
{3, 4, 5}
{1, 2}
{6, 7}
{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6}
{1, 2, 4, 5, 6}

리스트나 튜플은 순서가 있기 때문에 인덱싱을 통해 자료형의 값을 얻을 수 있다.

그러나 딕셔너리와 집합은 순서가 없기 때문에 인덱싱으로 값을 얻을 수 없다. 대신, 딕셔너리의 키 혹은 집합의 원소를 이용해 O(1)의 시간 복잡도로 조회할 수 있다. (이때 키와 원소의 값은 변경 불가한(Immutable) 값이어야 한다.)

기본 입출력

# 기본 입출력
# input() : 한 줄의 문자열을 입력 받는 함수
# map() : 리스트의 모든 원소에 각각 특정한 함수를 적용하는 함수

# 데이터의 개수 입력
n = int(input())
print(n)

# 각 데이터를 공백을 기준으로 구분하여 입력
data = list(map(int, input().split()))
data.sort(reverse = True)
print(data)

# a, b, c를 공백을 기준으로 구분하여 입력
a, b, c = map(int, input().split())
print(a, b, c)

# 빠르게 입력받기
# sys 라이브러리에 내장된 sys.stdin.readLine() 메서드를 이용
# 입력 후 엔터가 줄 바꿈 기호로 입력되므로 rstrip() 메서드 함께 사용
import sys

# 문자열 입력 받기
data = sys.stdin.readline().rstrip()
print(data)

# 표준 출력 방법
# print() 함수를 이용하며 ,를 이용해 각 변수를 구분 가능
# 기본적으로 출력 이후에 줄 바꿈을 수행, 원치 않는 경우 end 속성 이용
a = 1
b = 2
print(a, b)
print(7, end=" ")
print(8, end=" ")

# 출력할 변수
answer = 7
print("정답은 " + str(answer) + "입니다.")

# f-string 
# 3.6부터 지원, 문자열 앞에 접두사 f를 붙여 사용
answer = 7
print(f"정답은 {answer}입니다.")

실행 결과
[입력 부분]
1
1
1 2 3
[3, 2, 1]
1 2 3
1 2 3
baboya
baboya
[출력 부분]
1 2
7 8 정답은 7입니다.
정답은 7입니다.

조건문

# 들여쓰기
# 파이썬 공식 가이드라인에서는 '4개의 공백 문자'를 들여쓰기 표준으로 설정

# 조건문 기본 형태
# if 조건문 1:
#     조건문이 1이 True일 때 실행되는 코드
# elif 조건문 2:
#     조건문 1에 해당하지 않고, 조건문이 2가 True일 때 실행되는 코드
# else:
#     위의 모든 조건문이 True 값이 아닐 때 실행되는 코드

# 조건문 예제 : 성적 출력
score = 85

if score >= 90:
  print("학점 : A")
elif score >= 80:
  print("학점 : B")
elif score >= 70:
  print("학점 : C") 
else:
  print("학점 : F")

  # 논리 연산자
if True and True:
  print("True")
if True or False:
  print("True")
if not False:
  print("True")

a = 15

if a <= 20 and a >= 0:
  print("True")

# 기타 연산자
# x in 리스트 : 리스트 안에 x가 들어가 있을 때 True
# x not in 문자열 : 문자열 안에 x가 들어가 있지 않을 때 True

# pass 키워드
# 아무것도 처리하고 싶지 않을 때 사용
# 디버깅 과정에서 일단 조건문의 형태만 만들고, 처리 부분은 비워놓고 싶은 경우
if score >= 80:
  pass # 나중에 작성할 코드
else:
  print("성적이 80점 미만입니다.")
print("프로그램을 종료합니다.")

# 조건문의 간소화
# 조건문에서 실행될 코드가 한 줄인 경우, 줄 바꿈 필요 x
if score >= 80: result = "Success"
else: result = "Fail"
print(result)

# 조건부 표현식은 if ~ else문을 한 줄에 작성하게 해줌
result = "Success" if score >= 80 else "Fail"
print(result)

# 부등식 사용법
# 기존의 방식
x = 15
if x >= 0 and x < 20:
  print("x는 0 이상 20 미만의 수입니다.")

# 새로운 방식
if 0 <= x < 20:
  print("x는 0 이상 20 미만의 수입니다.")
  
실행 결과
학점 : B
True
True
True
True
프로그램을 종료합니다.
Success
Success
x는 0 이상 20 미만의 수입니다.
x는 0 이상 20 미만의 수입니다.

반복문

# while문
i = 1
result = 0

# 1 ~ 9까지의 합
while i <= 9:
  result += i;
  i += 1

print(result)

i = 1
result = 0

# 1 ~ 9까지 홀수의 합
while i <= 9:
  if i % 2 == 1:
    result += i
  i += 1

print(result)

# for문
# for 변수 in 리스트:
#   실행할 소스코드
arr = [9, 8, 7, 6, 5]
for x in arr:
  print(x)

# range() : 연속적인 값을 차례대로 순회할 때 주로 사용
# range(시작 값, 끝 값 + 1) 형태
# 인자를 하나만 넣으면 자동으로 시작 값은 0이 된다.
result = 0

# i는 1부터 9까지의 모든 값을 순회
for i in range(1, 10):
  result += i

print(result)

# continue
# 반복문에서 남은 코드의 실행을 건너뛰고 다음 반복을 진행할 때 사용
result = 0

# 1 ~ 9까지 홀수의 합
for i in range(1, 10):
  if i % 2 == 0:
    continue
  result += i

print(result)

# break
# 반복문을 즉시 탈출할 때 사용
i = 1

while True:
  print("현재의 값 : ", i)
  if i == 5:
    break
  i += 1

# 학생들의 합격 여부 판단 예제
scores = [90, 85, 77, 65, 97]

for i in range(5):
  if scores[i] >= 80:
    print(i + 1, "번 학생은 합격입니다.")

cheating_student_list = {2, 4}

for i in range(5):
  if i + 1 in cheating_student_list:
    continue
  if scores[i] >= 80:
    print(i + 1, "번 학생은 합격입니다.")

# 중첩 반복문, 구구단 예제
for i in range(2, 10):
  for j in range(1, 10):
    print(i, "X", j, "=", i * j)
  print()
  
실행 결과
45
25
9
8
7
6
5
45
25
현재의 값 :  1
현재의 값 :  2
현재의 값 :  3
현재의 값 :  4
현재의 값 :  5
1 번 학생은 합격입니다.
2 번 학생은 합격입니다.
5 번 학생은 합격입니다.
1 번 학생은 합격입니다.
5 번 학생은 합격입니다.
2 X 1 = 2
2 X 2 = 4
2 X 3 = 6
2 X 4 = 8
2 X 5 = 10
2 X 6 = 12
2 X 7 = 14
2 X 8 = 16
2 X 9 = 18
...
(중략)

함수와 람다 표현식

# 함수
# 특정한 작업을 하나의 단위로 묶어 놓은 것을 의미
# 불필요한 소스코드의 반복을 줄일 수 있다.

# 함수의 종류
# 내장 함수 : 파이썬이 기본적으로 제공하는 함수
# 사용자 정의 함수 : 개발자가 직접 정의하여 사용할 수 있는 함수

# 함수 정의하기
# def 함수명(매개변수):
#     실행할 소스코드
#     return 반환 값

# 더하기 함수 예시
def add(a, b):
  return a + b

print(add(3, 7))

def add(a, b):
  print("함수의 결과 : ", a + b)

add(3, 7)

# 파라미터의 변수 직접 지정하기
add(b = 3, a = 7)

# global
# 지역 변수가 아닌 함수 바깥에 선언된 변수를 바로 참조
a = 0

def func():
  global a # 위에서 선언한 a를 참조
  a += 1

for i in range(10):
  func()

print(a)

arr = [1, 2, 3, 4, 5]

def func():
  global arr
  arr = [3, 4, 5]
  arr.append(6)

func()
print(arr)

# 여러 개의 반환 값
def operator(a, b):
  add_var = a + b
  substract_var = a - b
  multiply_var  = a * b
  divde_var = a / b
  return add_var, substract_var, multiply_var, divde_var

a, b, c, d = operator(7, 3)
print(a, b, c, d)

# 람다 표현식
# 특정한 기능을 수행하는 함수를 한 줄에 작성할 수 있다.
print((lambda a, b: a + b)(3, 7))

# 자주 사용되는 람다 함수
arr = [("홍길동", 50), ("이순신", 32), ("아무개", 74)]

# 두 번째 원소를 기준으로 정렬한다.
def my_key(x):
  return x[1]

print(sorted(arr, key=my_key))
print(sorted(arr, key=lambda x: x[1]))

# 여러 개의 리스트에 적용
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

result = map(lambda a, b: a + b, list1, list2)

print(list(result))

실행 결과
10
함수의 결과 :  10
함수의 결과 :  10
10
[3, 4, 5, 6]
10 4 21 2.3333333333333335
10
[('이순신', 32), ('홍길동', 50), ('아무개', 74)]
[('이순신', 32), ('홍길동', 50), ('아무개', 74)]
[7, 9, 11, 13, 15]

유용한 표준 라이브러리

# 내장 함수
# 입출력 함수부터 정렬 함수까지 기본적인 함수들을 제공
# sum()
result = sum([1, 2, 3, 4, 5])
print(result)

# min(), max() 
min_result = min(7, 3, 5, 2)
max_result = max(7, 3, 5, 2)
print(min_result, max_result)

# eval() 
result = eval("(3 + 5) * 7")
print(result)

# sorted()
result = sorted([9, 1, 8, 5, 4])
reverse_result = sorted([9, 1, 8, 5, 4], reverse=True)
print(result)
print(reverse_result)

# sorted() with key
arr = [("홍길동", 35), ("이순신", 75), ("아무개", 50)]
result = sorted(arr, key=lambda x: x[1], reverse=True)
print(result)

# itertools
# 파이썬에서 반복되는 형태의 데이터를 처리하기 위한 유용한 기능들을 제공
# 순열과 조합 라이브러리는 코테에서 자주 사용된다.

# 순열 : ABC, ACB, BAC, BCA, CAB, CBA
from itertools import permutations

data = ['A', 'B', 'C'] 

result = list(permutations(data, 3)) # 모든 순열 구하기
print(result)

# 조합 : AB, AC, BC 
from itertools import combinations

result = list(combinations(data, 2))
print(result)

# 중복 순열과 중복 조합
from itertools import product

result = list(product(data, repeat=2)) # 2개를 뽑는 모든 순열 구하기 (중복 허용)
print(result)

from itertools import combinations_with_replacement

result = list(combinations_with_replacement(data, 2)) # 2개를 뽑는 모든 조합 구하기 (중복 허용)
print(result)

# heapq
# 힙 자료구조를 제공
# 우선순위 큐 기능을 구현하기 위해 사용된다.

# bisect
# 이진 탐색 기능을 제공한다.

# collections
# 덱(deque), 카운터(Counter) 등의 유용한 자료구조를 포함한다.

# deque
# 큐를 구현할 때 보통 사용한다.
# 별도로 제공하는 Queue 라이브러리는 일반적인 큐 자료구조와 조금 다르다.
# 리스트와 다르게 인덱싱, 슬라이싱 등의 기능은 사용할 수 없다.
from collections import deque

data = deque([2, 3, 4])

data.appendleft(1) # O(1)
data.append(5) # O(1)
print(list(data))

data.popleft() # O(1)
data.pop() # O(1)
print(list(data))

# Counter
# 등장 횟수를 세는 기능을 제공 
# 리스트와 같은 반복 가능한 객체가 주어진 경우 내부의 원소가 몇 번씩 등장했는지 알려준다.
from collections import Counter

counter = Counter(["red", "blue", "red", "green", "blue", "blue"])

print(counter["blue"])
print(counter["green"])
print(dict(counter)) # 딕셔너리 형태로 변환

# math
# 필수적인 수학적 기능을 제공
# 팩토리얼, 제곱근, 최대공약수, 삼각함수 관련 함수 등을 포함한다.

# 팩토리얼
import math

print(math.factorial(5))

# 제곱근
print(math.sqrt(7))

# 최대공약수/최소공약수
def lcm(a, b):
  return a * b // math.gcd(a, b)

a = 21
b = 14

print(math.gcd(a, b)) # 최대공약수 계산
print(lcm(a, b)) # 최소공약수 계산

# 파이(pi)와 자연상수(e)
print(math.pi)
print(math.e)

실행 결과
15
2 7
56
[1, 4, 5, 8, 9]
[9, 8, 5, 4, 1]
[('이순신', 75), ('아무개', 50), ('홍길동', 35)]
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]
[('A', 'B'), ('A', 'C'), ('B', 'C')]
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
[1, 2, 3, 4, 5]
[2, 3, 4]
3
1
{'red': 2, 'blue': 3, 'green': 1}
120
2.6457513110645907
7
42
3.141592653589793
2.718281828459045

2021년 하반기 취업 준비 일단 마무리...

노력의천재 — Sun, 9 Jan 2022 03:27:14 +0900

2021년 하반기를 마무리하며...!

내 인생에서 2021년은 다사다난한 해였다. 상반기에 ICT 학점연계 인턴십에 참여하여 운이 좋게 합격하게 됐고, 덕분에 인턴 경험을 할 수 있었다. 인턴 기간이 끝나고 건강 문제로 잠깐 쉬는 시간을 가졌으며, 2014년 3월부터 2021년 8월, 길고 길었던 대학 생활을 마무리하였다. 그 외에도 다양한 사건이 있었지만 이를 다 나열하기엔 무리가 있을 것 같다.

어찌됐든 본격적으로 회사에 지원서를 넣기 시작했고, 2021년 하반기, 취업에 성공할 수 있었다.

코딩테스트 개복치라서 항상 너무 힘들었다. (항상 1문제 차이로 탈락해서 더 멘붕이었다 ㅠㅠ...) 비록 처음 목표로 했던 기업은 아니었지만, 면접 성공률 100%를 달성한 것은 큰 성과라고 생각한다.

기회는 준비된 사람에게 찾아온다고 생각한다. Seize the day! 오늘을 충실히, 열심히 살자!
취준생 여러분 모두 원하는 기업으로 취업할 수 있기를 바라며....! 결산으로 마무리하도록 하겠다.

지원 기업

NHN, NHN 커머스, 라인, 네이버, 현대오토에버, 다우기술, 베이글코드, 엔픽셀, 한국IBM, 카페24, 안랩, 원스토어, 무신사, 마이리얼트립, 딜리버리 히어로, 피플펀드컴퍼니, 액심베이, LG CNS, CJ 올리브네트웍스, 에프앤에프

서류 합격

NHN(자소서 x), NHN 커머스, 카카오(자소서 x), 라인, 네이버, 현대오토에버, 다우기술, 베이글코드(자소서 x), 엔픽셀(자소서 x), 한국 IBM, 카페24(프로그래머스 매칭)

인적성/필기/코테 합격

현대오토에버, 다우기술, 카페24

인적성/필기/코테 불합격

카카오(코테 탈), 라인(코테 탈), 네이버(코테 탈), NHN(필기 탈), NHN 커머스(코테 탈), 한국IBM(인적성 + 코테 탈), 액심베이(과제 미제출), 베이글코드(코테 탈), 엔픽셀(코테 불참)

1차 면접 합격

현대오토에버, 카페24, 다우기술(인턴 입사 포기)

2차 면접 합격

현대오토에버, 카페24

오픽 후기

https://transferhwang.tistory.com/677

오픽(OPic) IH를 단기간에 취득하는 방법

취업 시장에서의 오픽 중요도 증가 많은 취업 준비생들이 원하는 기업에 취업하기 위해 어학 자격증을 취득하고 있다. 이는 과거부터 지금까지 대기업, 공기업 등 대부분의 기업들이 지원자로

transferhwang.tistory.com

면접 후기

https://transferhwang.tistory.com/634

2021년 하반기 현대오토에버 신입 공채 후기

지원 직무 1지망 : ICT - 모빌리티 2지망 : ICT - 스마트 팩토리 인성 검사(HMAT) https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=702lab&logNo=221437756527 현대자동차 HMAT 인성검사 후..

transferhwang.tistory.com

https://transferhwang.tistory.com/633

2021년 하반기 카페24 개발자 채용 챌린지 합격 후기

지원 직무 https://programmers.co.kr/competitions/1802/2021-cafe24-challenge 2021 카페24 개발자 채용 챌린지 온라인 쇼핑몰 솔루션 업계 1위,'카페24'개발자 채용 챌린지! 카페24는 창의가 있는 사람이라면..

transferhwang.tistory.com

https://transferhwang.tistory.com/632

2021년 하반기 다우기술 신입 공채 후기

지원 직무 1지망 : 웹 애플리케이션 개발 2지망 : x 3지망 : x 인적성 온라인으로 진행되며, 인성검사와 직무능력검사를 한번에 보며 대략 100분정도 소요됐다. 인터넷에 찾아보면 평균에서 조금 낮

transferhwang.tistory.com

2021년 하반기 현대오토에버 신입 공채 합격후기

노력의천재 — Thu, 6 Jan 2022 02:10:03 +0900

지원 직무

1지망 : ICT - 모빌리티

2지망 : ICT - 스마트 팩토리

서류 전형

자소서 문항은 두 개밖에 없어 작성하는데 어렵진 않았으나, 두 개의 문항에 내가 어떤 개발자로 성장하길 원하며, 어떤 준비를 해왔는지를 구체적으로 표현하기 위해 많은 시간을 투자하였다.

서류 합격

서류 전형 결과는 꽤 시간이 지나서 발표하였다. 기대하지 않고 메일을 확인하였는데, 위와같이 합격 메일이 와있었다. 그때부터 부랴부랴 현대오토에버의 채용 절차에 대해 열심히 찾아보기 시작했다...

인성 검사(HMAT)

https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=702lab&logNo=221437756527

현대자동차 HMAT 인성검사 후기 및 팁!

얼마 전 잡플랫 카페에서 현대엠엔소프트, 현대홈쇼핑 등 각종 현대계열사 채용공고를 보고 이번 주 인성검...

blog.naver.com

현대오토에버의 인성 검사는 현대차그룹의 HMAT 인성 검사로 진행된다. 인성 검사 전에 위의 링크를 참고한 후, 솔직하게 인성 검사를 진행하였다. 문항은 그렇게 많지 않았기에 약 60분정도 걸렸던 것 같다. 나중에 알게된 사실인데 인성 검사가 생각보다 중요한 비중을 차지하는 것 같다.

코딩테스트

오전에 인성 검사를 진행하고 오후에 코테를 보게된다. 시험 환경은 프로그래머스였고 2시간 동안 알고리즘 2문제, SQL 1문제, 총 3문제를 풀어야 했다. 난이도는 네카라 코테에 비하면 굉장히 쉬운 편이라 전부 풀어 제출하였다. 물론 정답 공개를 하지 않아서 올솔 했는지는 알 수 없다. 내가 풀었던 문제는 실버5, 골드3~5 정도였는데, 들어보니 지원자마다 각각 문제가 달랐던 것 같다. (또 어떤 부서는 과제 테스트였다.)

HMAT + 코딩테스트 합격

코테 결과는 시험을 보고 4일 뒤에 발표됐다. 자소설닷컴 채팅을 보면 1문제를 제출했는데 통과했다는 사람이 꽤 보였었다. 따라서 현대오토에버는 solve 문제 수보다 인성 검사 결과를 좀 더 중요하게 보지 않았을까 추측했었다.

1차 면접 후기

현대오토에버의 1차 면접은 A세션과 B세션, 총 두 개로 구성된다. A세션은 자소서를 기반으로 기초 직무 역량을 파악하는 형태이고 B세션은 코딩 테스트나 과제 테스트 결과를 기반으로 좀 더 심층적으로 직무 역량을 파악하는 형태라고 안내 되어있다. 코테 결과 발표 후 1~2주 뒤에 면접 날짜가 잡히는데, 날짜가 잡히자마자 바로 합격자 오카방에서 '현대오토에버 면접 스터디'를 구하여 정말 열심히 준비를 하였다.

A세션(면접관 2, 지원자 1, 20분)

자소서를 기반으로 인턴 때 진행했던 프로젝트에 대한 질문과 자바 기초에 대한 질문이 들어왔다. 그 외에도 CS, 인성 등 다양한 유형의 질문을 물어봤다. 기술 면접의 경우 상반기에 인턴 생활을 하면서 스터디를 병행하며 준비해왔고, 현대오토에버 면접 스터디를 통해 다양한 인성 질문을 준비했기 때문에 아주 무난하고 평이한 면접이었다. 또한, '관심있는 현대오토에버의 모빌리티 서비스가 있냐?'는 질문에 차랑간편결제 서비스인 현대카페이에 관심이 있다고 했는데, 마침 면접관님 본인 부서에서 해당 서비스를 개발하고 있다고 말씀해주셔서 훈훈한 면접 분위기를 만들어갈 수 있었다.

B세션(면접관 1, 지원자 1, 30분)

A세션이 끝나면 바로 B세션 링크로 들어가 시작할 때까지 대기를 하게 된다. 분명 안내에 의하면 코테 결과를 기반으로 심층적 직무 역량 파악을 한다고 기재되어 있는데, 나 같은 경우 코테에 대한 언급을 1도 안하셨다. 면접 시작 후 바로 '인턴 때 뭐 했나?'라는 질문을 시작으로 자연스럽게 '모놀리스와 MSA의 차이점' 같은 기술 면접 질문들이 쏟아졌다. 면접관님은 신나게 질문 공세를 하시다가 30분이 지난 것을 확인하시고 궁금한 거 있냐고 마지막으로 질문하셨고, 질문의 대답을 해주신 후 본인 부서에 대한 장점을 어필하며 최종합격 한다면 뒤도 돌아보지말고 오라며 격려해주셨다. (해당 회사로 입사하기로 결정한 가장 결정적인 이유 중 하나이다.)

1차 면접 합격

질문의 약 90% 정도는 아는 내용이라 잘 이야기한 것 같은데 나머지 10%에 대한 질문은 키워드조차 처음 들어보는 것들이 많아 아직도 공부할 게 너무 짱 많구나라는 것을 깨닫게 되었다. 난생 처음 들어보는 거라서 복기할 때도 전혀 기억이 안났다 ㅠㅠ,,, 나중에 면접관님을 만나게 된다면 그 때 물어봤던게 뭐였는지 여쭤보고 싶은데... 아마 못만날수도... 만나도 뭐 질문했는지 이미 잊어버리셨을 것 같다...

2차 면접 후기(면접관 3, 지원자 1, 15분)

임원 면접이라고 생각했지만 팀장 1명, 인사 담당자 1명, 임원 1명으로 구성되어 있었던 것으로 추측된다. 또한, 원래는 다대다 면접이지만 나의 경쟁자분은 다른 좋은 곳으로 가셨는지... 나 혼자 면접을 봤다. 2차 면접은 스펙타클했는데, 자기소개를 하고나서 한 15초동안 아무도 나에게 질문을 하지 않았다. 나 뭐 실수했나 긴장하고 있었는데 팀장님이랑 임원님이 내 마이크 소리가 하나도 안들린다고 하셔가지고 갑자기 멘붕이 왔었다. 그러나 다행히 인사 담당자님은 잘 들었다고 말씀해주셨고, 내 마이크 문제가 아닌 것을 알 수 있었다. 그래서 약 10분정도 면접의 딜레이가 발생하였고, 문제가 해결된 후 다시 한번 자기소개를 시작하며 면접을 진행할 수 있었다.

팀장님과 임원께서는 합쳐서 질문을 4개밖에 안하셨고, 대부분 인사 담당자님의 인성 질문으로 구성되었다. 나의 성격(인성 검사를 통해 내성적인 성격이 나왔다고 추측)과 개발 가치관에 대해 검증하려는 것 같았다. 뇌피셜이긴 하지만 2차 면접보다는 1차 면접이 더 중요하게 느껴졌다.

최종 결과

최종 합격

2차 면접에 합격하고 채용검진을 하고나면 마침내 최종 합격하게 된다.

최종 합격 후기

입사 축하 꽃바구니, 편지

대기업 IT 계열사는 아무래도 서비스 기업보다 딱딱한 분위기고 개발자로서의 성장 기회가 적을 것 같은 이미지였는데, 현대오토에버는 나의 고정관념을 깼다. 먼저 job description이 다른 대기업 IT 계열사와 비교했을 때 꽤 구체적이라 내가 해당 직무에 지원하게 됐을 때 어떤 커리어를 쌓아갈 수 있을지 좀 더 명확해서 좋았다. 또한, 1차 면접 때 면접관님들이 전부 젠틀했고, 연령대도 많이 젊은 편이라 팀 분위기가 활기 넘치고 좋아보였다. 게다가 본인 부서에 대한 자긍심과 함께 장점을 명확히 어필해주니 신입 개발자로서 입사하게 됐을 때 많이 성장할 수 있을 것이라고 판단하였다. 물론! 나의 선택이 옳았는 지는 출근해서 일 해봐야 알겠지만... 일단 올해 취업해서 너무 좋다.

추가로 기술면접 스터디를 진행하면서 정리했던 내용들을 참고하여 하반기 공채 면접때 많은 도움이 되었는데, 개발자로서 취업을 원하는 취준생 여러분에게 조금이나마 도움이 되었으면 좋겠다 ㅎㅎ

https://github.com/workhardslave/cs-study

GitHub - workhardslave/cs-study: 신입 개발자가 알아야 할 cs 전공 지식

신입 개발자가 알아야 할 cs 전공 지식. Contribute to workhardslave/cs-study development by creating an account on GitHub.

github.com

마무리로, 이 글을 보는 미래의 누군가도 합격의 기운을 받아 원하는 기업에 취뽀하기를 바란다!

취업 후기

https://transferhwang.tistory.com/630

2021년 하반기 취업 준비 일단 마무리...

2021년 하반기를 마무리하며...! 내 인생에서 2021년은 다사다난한 해였다. 상반기에 ICT 학점연계 인턴십에 참여하여 운이 좋게 합격하게 됐고, 덕분에 인턴 경험을 할 수 있었다. 인턴 기간이 끝나

transferhwang.tistory.com

2021년 하반기 카페24 개발자 채용 챌린지 합격 후기

노력의천재 — Tue, 4 Jan 2022 22:46:45 +0900

지원 직무

https://programmers.co.kr/competitions/1802/2021-cafe24-challenge

2021 카페24 개발자 채용 챌린지

온라인 쇼핑몰 솔루션 업계 1위,'카페24'개발자 채용 챌린지! 카페24는 창의가 있는 사람이라면 누구나 국내를 넘어 전 세계 시장에서 온라인 비즈니스가 가능할 수 있도록 쇼핑몰 솔루션부터 글

programmers.co.kr

글로벌 마케팅 플랫폼 개발(풀스택)

코딩테스트

지원하는 직무에 따라 사용할 수 있는 언어가 다르다. 본인은 코테를 풀 때 주언어가 C++ 이었는데, 신입을 뽑는 직무중 해당 언어를 지원하는 직무가 글로벌 마케팅 플랫폼 개발밖에 없었다. 기술적으로는 데이터 플랫폼 개발쪽으로 지원하고 싶었지만, 일단 코테를 통과하는 것이 급선무라고 생각했다. ~~근데 문제가 ㄹㅇ 너무 쉬웠다. 백준 브론즈 수준~~

코테가 너무 쉬워 변별력이 없었기 때문에 챌린지 접수에 사용했던 포트폴리오에 따라 면접의 기회가 주어졌을 것이라고 조심스럽게 추측해본다.

1차 면접(실무 + 인성 면접)

코테와 포트폴리오 전형(?)이 합격하게 되면 문자로 연락이오고, 시간이 지나 유선을 통해 면접 날짜를 잡게된다. 1차 면접은 두 번의 면접을 이어서 보게된다. 첫 번째는 내가 지원한 부서의 팀장님, 팀원들과의 실무 면접, 두 번째는 인사 담당자님과의 인성 면접으로 구성된다. 실무면접은 다대일, 인성 면접은 일대일이며 온라인으로 진행된다.

실무 면접은 포트폴리오에 작성했던 프로젝트를 기반으로 많은 질문이 들어오고, 지원자의 개발 철학이 팀의 문화와 잘 맞는지를 확인하는 것 같았다. 인성 면접은 지원자의 관심사와 성격, 카페24에 대한 관심도가 어느 정도인지를 확인하고 연봉 협상을 하게된다.

2차 면접(CTO 면접)

1차 면접의 결과도 역시 유선을 통해 전달되고 면접 날짜를 협상한다. 생애 첫 CTO 면접이라서 많이 긴장한 상태로 면접을 봤다. (만약 온라인이 아니었다면 더 긴장했을 것이다.) CS, 프로젝트, 인성, 창의력 등 다양한 유형의 질문을 받았고 난이도는 상당했다. 본인의 개발 커리어에 대한 목표와 개발 철학이 무엇인지에 대해 깊은 고민을 하고 면접을 본다면 굉장히 큰 도움이 될 것이라고 생각한다.

최종 결과

최종 합격

느낀 점

비록 다른 회사에 합격하여 입사를 포기하긴 했지만 자유롭고 수평적인 팀 분위기임을 간접적으로 느낄 수 있었고, 개발자로서 성장할 수 있는 기회가 많을 것이라고 판단했다. 또한, 가장 인상적인 것은 지원자를 굉장히 배려해주는 회사였다는 것이다. (특히 인사 담당자님이 매우 친절하시다.) 언젠가 기회가 된다면 꼭 한 번 일 해보고 싶은 회사이고 주위 사람들에게도 지원을 권유해보고 싶다.

2021년 하반기 다우기술 신입 공채 후기

노력의천재 — Mon, 3 Jan 2022 22:55:28 +0900

지원 직무

1지망 : 웹 애플리케이션 개발
2지망 : x
3지망 : x

인적성

다우기술은 인성검사와 직무능력검사를 한번에 보며 모두 온라인으로 진행되었다. (대략 100분정도 소요) 인터넷에 찾아보면 평균에서 조금 낮은 수준의 난이도라는데 나같은 경우는 매번 코딩테스트 준비만 했었기 때문에 개인적으로 많이 어려웠다.

코딩테스트

다우기술의 특이한(?) 부분이라고 할 수 있는데, 일반적인 기업의 코테와 다르게 COS PRO 라는 자격증 시험의 형태로 코테가 진행된다. 유형은 빈칸 넣기, 틀린 코드 고치기, 구현하기 세 가지 유형을 가지고 총 10문제를 90분동안 풀어야 한다. 그리고 온라인으로 진행되는 것이 아니라 신촌 YBM 센터에서 시험을 봐야하는데 성가셨다;; 난이도는 평상시에 코테 준비를 했다면 쉬운편이라 어렵지 않게 통과할 수 있을 것이라 판단된다. (아래 링크에서 기출문제를 확인할 수 있다.)

https://edu.goorm.io/lecture/17300/cos-pro-1%EA%B8%89-%EA%B8%B0%EC%B6%9C%EB%AC%B8%EC%A0%9C-c

COS PRO 1급 기출문제 - C++ - 구름EDU

YBMIT에서 시행하는 COS Pro 자격증으로 기출문제를 직접 풀어볼 수 있는 실습 위주의 강좌입니다.

edu.goorm.io

※ 본인은 코테에서 주 언어로 C++을 사용해서 C++ 링크를 남겼지만, 찾아보면 자바, 파이썬 다양하게 있다.

실무 면접

다우기술의 인적성/코테를 합격하게 되면 실무 면접 관련 이메일을 받게된다. 여기서 중요한 것은 면접에 대한 정확한 날짜와 시간은 다우기술 채용 홈페이지에서 직접 확인해야 한다는 것이다. (본인은 이를 면접 당일에 알아버렸다.) 면접 복장은 양복을 입어야 하며, 온라인으로 면접관 3명, 지원자 1명인 다대일 형태로 진행됐다. 질문 내용은 평이했기에 막힘없이 대답하였다.

질문 내용

자기소개
프로젝트를 하나만 기재했는데 다른거 없나?
졸업 프로젝트 뭔지 설명, 어떤 업무?
JPA가 뭔지 설명, JPA 안 어려웠나?
유효성 검사를 어떻게 개발했는가?
인턴생활 했는데 뭐했냐?
학부시절과 현재 개발 습관의 비교
학부시절 과목중 중요하다고 생각하는거?
왜 운영체제가 중요하다고 생각하나?
프로세스, 스레드, 스레드풀 개념?
다우기술 서비스 사용해본거 있나?
마지막 한마디
면접관의 피드백

최종 결과

실무 면접 합격

실무 면접에 합격하게 되면 필요한 서류를 제출하고 다우기술의 인턴 사원으로 입사하게 된다. 본인은 다른 회사의 면접 결과를 기다림과 동시에 준비중이었기 때문에 입사를 포기하였다. 또한, 인턴 채용의 경우 정규직으로 전환되지 않을 리스크도 있기 때문에 안전하지 않다고 생각하였다.

느낀 점

면접과 OT때 양복을 입어야하는 게 뭔가 수직적인 회사라는 느낌이 들어(지극히 개인적인 의견) 거부감이 생긴 것 같다. 그래도 면접을 보면서 마지막에 피드백을 줬던 경우는 처음이라 신기했고 나의 부족한 점을 알 수 있는 귀중한 경험이었다.

[백준/BOJ] 1051번 숫자 정사각형 (C++)

노력의천재 — Tue, 16 Nov 2021 17:34:48 +0900

https://www.acmicpc.net/problem/1051

1051번: 숫자 정사각형

N×M크기의 직사각형이 있다. 각 칸에는 한 자리 숫자가 적혀 있다. 이 직사각형에서 꼭짓점에 쓰여 있는 수가 모두 같은 가장 큰 정사각형을 찾는 프로그램을 작성하시오. 이때, 정사각형은 행

www.acmicpc.net

문제의 이해가 좀 어려웠는데, 난이도는 쉬운 문제였다. 꼭지점의 값이 모두 같은 가장 큰 정사각형의 넓이를 찾는 완전 탐색(브루트 포스) 문제였다.

#include <iostream>
#include <algorithm>
using namespace std;

int map[51][51];

int main(void) {
	freopen("input.txt", "rt", stdin);
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	
	int n, m, answer = 1;
	cin >> n >> m;
	for(int i = 0; i < n; i++) {
		string num;
		cin >> num;
		for(int j = 0; j < num.size(); j++) {
			map[i][j] = num[j] - '0';
		}
	}
	
	for(int k = 2; k <= min(n, m); k++) {
		for(int i = 0; i < n - k + 1; i++) {
			for(int j = 0; j < m - k + 1; j++) {
				if(map[i][j] == map[i + k - 1][j] && map[i][j] == map[i][j + k - 1] && map[i][j] == map[i + k - 1][j + k - 1]) {
					answer = max(answer, k * k);
				}
			}
		}
	}

	cout << answer;
}

[백준/BOJ] 1600번 말이 되고픈 원숭이 (C++)

노력의천재 — Thu, 4 Nov 2021 15:17:22 +0900

https://www.acmicpc.net/problem/1600

1600번: 말이 되고픈 원숭이

첫째 줄에 정수 K가 주어진다. 둘째 줄에 격자판의 가로길이 W, 세로길이 H가 주어진다. 그 다음 H줄에 걸쳐 W개의 숫자가 주어지는데, 0은 아무것도 없는 평지, 1은 장애물을 뜻한다. 장애물이 있

www.acmicpc.net

2206번 벽 부수고 이동하기를 응용한 것 같은 문제였다. 해당 문제를 해결했다면 어렵지 않았을 BFS 문제다.

#include <iostream>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;

struct Pos {
	int x, y, cnt;
};

int k, w, h;
int map[201][201];
int visit[31][201][201];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
int hx[8] = {-2, -2, -1, 1, 2, 2, -1, 1};
int hy[8] = {-1, 1, -2, -2, -1, 1, 2, 2};

int BFS() {
	queue<Pos> q;
	q.push({ 0, 0, k });
	visit[k][0][0] = 0;
	
	while(!q.empty()) {
		int x = q.front().x;
		int y = q.front().y;
		int cnt = q.front().cnt;
		q.pop();
		
		if(x == h - 1 && y == w - 1) return visit[cnt][x][y];
		
		if(cnt > 0) {
			for(int i = 0; i < 8; i++) {
				int nx = x + hx[i];
				int ny = y + hy[i];
				if(nx >= 0 && nx < h && ny >= 0 && ny < w) {
					if(visit[cnt - 1][nx][ny] == -1 && map[nx][ny] == 0) {
						q.push({ nx, ny, cnt - 1 });
						visit[cnt - 1][nx][ny] = visit[cnt][x][y] + 1;
					}
				}
			}
		}
		
		for(int i = 0; i < 4; i++) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if(nx >= 0 && nx < h && ny >= 0 && ny < w) {
				if(visit[cnt][nx][ny] == -1 && map[nx][ny] == 0) {
					q.push({ nx, ny, cnt });
					visit[cnt][nx][ny] = visit[cnt][x][y] + 1;
				}
			}
		}
	}
	
	return -1;
}

int main(void) {
	//freopen("input.txt", "rt", stdin);
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	
	cin >> k >> w >> h;
	for(int i = 0; i < h; i++) {
		for(int j = 0; j < w; j++) {
			cin >> map[i][j];
		}
	}
	
	memset(visit, -1, sizeof(visit));
	cout << BFS();
}

[백준/BOJ] 1527번 금민수의 개수 (C++)

노력의천재 — Tue, 2 Nov 2021 16:51:56 +0900

https://www.acmicpc.net/problem/1527

1527번: 금민수의 개수

첫째 줄에 A와 B가 주어진다. A는 1보다 크거나 같고, 1,000,000,000보다 작거나 같은 자연수이다. B는 A보다 크거나 같고, 1,000,000,000보다 작거나 같은 자연수이다.

www.acmicpc.net

간단한 완전탐색(브루트포스) 문제였다. 4와 7로 이루어진 1~9번째 자리의 숫자를 DFS로 모두 구해준 후, 이를 벡터에 저장했다. 그 후, 입력으로 들어온 a와 b 사이에 있는 값이 벡터에 몇개 들어있는지 찾으면 된다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int a, b, answer;
vector<int> v;

void DFS(int cnt, int len, string now) {
	if(cnt == len) {
		v.push_back(stoi(now));
		return;
	}
	
	DFS(cnt + 1, len, now + "4");
	DFS(cnt + 1, len, now + "7");
}

int main(void) {
	//freopen("input.txt", "rt", stdin);
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	
	cin >> a >> b;
	
	string num = "";
	for(int i = 1; i <= 9; i++) {
		DFS(0, i, num);
	}

	for(int i = 0; i < v.size(); i++) {
		if(v[i] >= a && v[i] <= b) answer++;
	}
	
	cout << answer;
}

[백준/BOJ] 2573번 빙산 (C++)

노력의천재 — Tue, 2 Nov 2021 16:28:30 +0900

https://www.acmicpc.net/problem/2573

2573번: 빙산

첫 줄에는 이차원 배열의 행의 개수와 열의 개수를 나타내는 두 정수 N과 M이 한 개의 빈칸을 사이에 두고 주어진다. N과 M은 3 이상 300 이하이다. 그 다음 N개의 줄에는 각 줄마다 배열의 각 행을

www.acmicpc.net

문제의 조건을 정리하며 차례대로 구현하면 어렵지 않게 해결할 수 있는 BFS 문제였다.

1. map 입력을 받는다.
2. map[i][j] > 0, 현재 빙산과 접하는 바닷물의 수를 구하고, 이를 현재 빙산에서 빼준다.
(그 뺀 값이 음수라면 0으로 바꿔주기)
3. 모든 map에 대해 2번 작업을 완료했다면, BFS를 통해 분리된 덩어리의 수를 구한다.
4. 분리된 덩어리의 수가 2보다 크거나 같다면 종료, 아니라면 2번 작업으로 돌아간다.
+ 모든 빙산이 녹아있는 경우 0을 리턴한다.

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;

struct Pos {
	int x, y, melt;
};

int n, m, time;
int map[301][301];
bool visit[301][301];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};

void BFS(int sx, int sy) {
	queue<pair<int, int> > q;
	q.push({ sx, sy });
	visit[sx][sy] = true;
	
	while(!q.empty()) {
		int x = q.front().first;
		int y = q.front().second;
		q.pop();
		
		for(int i = 0; i < 4; i++) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if(!visit[nx][ny] && map[nx][ny] > 0) {
				q.push({ nx, ny });
				visit[nx][ny] = true;
			}
		}
	}
}

int melting(int x, int y) {
	int res = 0;
	
	for(int i = 0; i < 4; i++) {
		if(map[x + dx[i]][y + dy[i]] == 0) res++;
	}
	
	return res;
}

int main(void) {
	//freopen("input.txt", "rt", stdin);
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	
	cin >> n >> m;
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < m; j++) {
			cin >> map[i][j];			
		}
	}
	
	bool flag = true;
	while(flag) {
		time++;
		flag = true;
		memset(visit, false, sizeof(visit));
		vector<Pos> v;
		
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < m; j++) {
				if(map[i][j] > 0) {
					v.push_back({ i, j, melting(i, j) });
				}
			}
		}
		
		if(v.empty()) {
			cout << "0";
			exit(0);
		}
		
		for(int i = 0; i < v.size(); i++) {
			int x = v[i].x;
			int y = v[i].y;
			int melt = v[i].melt;
			map[x][y] -= melt;
			if(map[x][y] < 0) map[x][y] = 0;
		}
		
		int cnt = 0;
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < m; j++) {
				if(map[i][j] > 0 && !visit[i][j]) {
					BFS(i, j);
					cnt++;
					if(cnt >= 2) {
						flag = false;
						break;
					}
				}
			}
			if(!flag) break;
		}
	}
	
	cout << time;
}

[백준/BOJ] 2206번 벽 부수고 이동하기 (C++)

노력의천재 — Fri, 29 Oct 2021 15:04:19 +0900

https://www.acmicpc.net/problem/2206

2206번: 벽 부수고 이동하기

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로

www.acmicpc.net

벽 뚫기 사용의 유무를 체크하기 위해 3차원 배열을 이용해야 한다. 해당 아이디어만 잘 떠올린다면 어렵지 않게 해결할 수 있는 BFS 문제였다.

#include <iostream>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;

int N, M;
int map[1001][1001];
int visit[2][1001][1001];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};

struct Pos {
	int x, y, flag; // flag - 0 : 벽 뚫기를 아직 사용 안함, 1: 벽 뚫기를 이미 사용함
};

int BFS() {
	queue<Pos> q;
	q.push({ 0, 0, 0 });
	visit[0][0][0] = 0;

	while(!q.empty()) {
		int x = q.front().x;
		int y = q.front().y;
		int flag = q.front().flag;
		q.pop();
		
		if(x == N - 1 && y == M - 1) return visit[flag][x][y] + 1;
		
		for(int i = 0; i < 4; i++) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if(nx >= 0 && nx < N && ny >= 0 && ny < M) {
                // 탐색하는 칸을 처음 방문하고, 벽이 없을 때
				if(visit[flag][nx][ny] == -1 && map[nx][ny] == 0) {
					q.push({ nx, ny, flag });
					visit[flag][nx][ny] = visit[flag][x][y] + 1;
                // 탐색하는 칸에 벽이 있고, 아직 벽 뚫기를 사용 안했을 때
				} else if(map[nx][ny] == 1 && flag == 0) {
					q.push({ nx, ny, 1 });
					visit[1][nx][ny] = visit[flag][x][y] + 1;
				}
			}
		}
	}
	
	return -1;
}

int main(void) {
	//freopen("input.txt", "rt", stdin);
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	
	cin >> N >> M;
	for(int i = 0; i < N; i++) {
		string str;
		cin >> str;
		for(int j = 0; j < str.size(); j++) {
			map[i][j] = str[j] - '0';
		}
	}

	memset(visit, -1, sizeof(visit));
	cout << BFS();
}

[백준/BOJ] 5014번 스타트링크 (C++)

노력의천재 — Thu, 28 Oct 2021 17:26:30 +0900

https://www.acmicpc.net/problem/5014

5014번: 스타트링크

첫째 줄에 F, S, G, U, D가 주어진다. (1 ≤ S, G ≤ F ≤ 1000000, 0 ≤ U, D ≤ 1000000) 건물은 1층부터 시작하고, 가장 높은 층은 F층이다.

www.acmicpc.net

1697번 숨바꼭질 문제와 비슷한 BFS 문제였다. 그래서 어렵지 않게 해결 ㅎ (범위 처리만 잘 해주자)

#include <iostream>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;

int F, S, G, U, D;
int visit[1000001];

int BFS() {
	queue<int> q;
	q.push(S);
	visit[S] = 0;
	
	while(!q.empty()) {
		int now = q.front();
		q.pop();
		
		if(now == G) return visit[now];
		
		if(now + U <= F && visit[now + U] == -1) {
			q.push(now + U);
			visit[now + U] = visit[now] + 1;
		}
		
		if(now - D >= 1 && visit[now - D] == -1) {
			q.push(now - D);
			visit[now - D] = visit[now] + 1;
		}
	}
	
	return -1;
}

int main(void) {
	//freopen("input.txt", "rt", stdin);
	ios_base::sync_with_stdio(false);
	cin.tie(0);

	cin >> F >> S >> G >> U >> D;
	memset(visit, -1, sizeof(visit));
    
	int answer = BFS();
	if(answer == -1) cout << "use the stairs";
	else cout << answer;
}