이면지

큐시즘 31기를 끝마치며

한 면만 쓴 종이 — Fri, 6 Jun 2025 01:03:34 +0900

큐시즘 지원 계기

학교를 졸업 유예하고 계속 입사 지원서를 제출하고 코테 등 공부를 하며 지냈습니다.

매일매일 아침부터 도서관에서 공부하다 보니 사람 만날 일도 줄어들고 하루 종일 고독하더라고요.. (고독정식 9만 개)

그래서 동아리 활동이라도 하면서 사람을 좀 만나자는 생각을 했습니다. 그리고 가지고 있던 프로젝트들이 좀 오래되기도 했고요.

마침 큐시즘이 모집 중이길래 하루 만에 후다닥 써서 제출했습니다. 기존에 자소서를 써왔던 게 있어서 그래도 수월하게 작성했던 것 같아요.

큐시즘 들어가기

지원서

우선 백엔드 파트로 지원했습니다. 저는 주로 START 기법을 이용해서 자소서를 작성합니다. STAR 기법이 가장 유명한데, 저 같은 글 모지리에게는.. 자세하게 하나하나 무엇을 써야 하는지 정해져 있는 게 작성하기 쉽다고 느껴져서 해당 기법을 주로 사용하게 됐습니다. 어느 동아리던 회사던 지원하시려는 분들은 참고하셔도 좋을 것 같아요!

면접

면접은 기본 CS 지식을 주되게 준비해 갔어요. 근데 질문은 제 프로젝트 위주로 나왔답니다. 게다가 포트폴리오에만 있는 내용 기반 질문도 있어서 약간 당황하기도 했던 기억이 있어요. 그래도 본인이 직접 한 경험이라면 아예 대답을 못할 질문들은 없었던 것 같아요.

하지만 저는 당황해서 조금 틀리게 답했던 것두 있었어요 ㅎㅎ

기업프로젝트

밀크걸즈라는 팀과 기업 프로젝트를 진행했어요. 서울우유 기업 과제였는데 정말 정말 좋은 경험이었습니다.

사람들도 좋았고 결과물도 좋았어요.

기간이 짧다 보니 밤을 정말.. 정말 많이 새웠어요. 그래도 그만큼 보람찼습니다.

간략히 프로젝트를 소개해보자면, 지능형 세금계산서 검증 시스템입니다.

사람이 일일이 홈택스에서 세금계산서를 검증하는 과정을 최대한 단축하는 것이 백엔드의 핵심이었어요.

제 생각에는 백엔드의 역할이 중요한 프로젝트였던 것 같아요.

홈택스에서 직접 세금계산서를 검증하는 과정을 단축한 방법은 CODEF API를 사용하는 것이었어요.

해당 API를 사용하는 과정에서 많은 시행착오를 겪었습니다. 우선, 본인인증 과정이 필요했는데, 이것 때문에 API 연동 방식이 많이 복잡했어요.

이 포스트에 기술적인 부분을 크게 담지는 않을 생각이라 자세한 설명은 생략하겠습니다..

여튼 해당 API를 연결하면서 한 단계 성장한 것 같아요.

그리고 같은 파트 팀원도 함께 열심히 해주어서 같이 으쌰으쌰 하는 분위기가 조성됐어요.

다른 파트들도 정말 열심히 하는 게 느껴져서 더 애정이 갔답니다..

밋업프로젝트

이건.. 팀명을 밝히지 않을게요 ㅎㅎ 조금 부끄러워서..

밋업 프로젝트로는 공모전에도 나가게 되었어요. 아직 결과가 나오지 않았는데 좋은 결과가 있었으면 좋겠네요.

밋업 프로젝트 사람들도 좋았습니다.

이 프로젝트는 기업 프로젝트보다는 백엔드의 중요도가 적었어요.

그래도 Spring AI를 사용해 본 것에 만족하고 있답니다. 여러분도 Spring AI 사용해 보세요. 이전처럼 DTO 무덤을 만들지 않아도 되고, 응답도 제시한 DTO에 담아서 줘서 정말 편해요!

아쉬웠던 점은 마지막 UT와 밋업데이를 가지 못했다는 거예요 ㅠㅠ

그래도 찐막인 큐시즘의 밤은 참석하기 때문에 그날 잘 즐기겠습니다.

지나 보니 짧았던 큐시즘 활동을 이렇게 잘 끝마치게 되어 뿌듯하네요.

좋은 기억 많이 쌓고 갑니다~

[프로그래머스] 징검다리 건너기 (자바)

한 면만 쓴 종이 — Fri, 28 Mar 2025 22:44:15 +0900

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

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

아래의 조건 때문에 완전탐색은 불가능하다고 판단했다.

stones 배열의 크기는 1 이상 200,000 이하입니다.
stones 배열 각 원소들의 값은 1 이상 200,000,000 이하인 자연수입니다.

그럼 DP 나 이분탐색을 사용해야 겠다고 생각했다.

- DP: DP를 적용해도 시간 복잡도 단축이 크지 않을 것 같았다. 최악의 경우 stones의 원소 값만큼 시간복잡도가 깊어질 수 있기 때문에..

- 이분탐색: 위의 이유로 이분탐색을 적용해야 겠다는 삘이 왔다.. 하지만 어떻게 적용해야 할지 감을 못 잡았다. 그래서 다른 분들 풀이를 참고했다.

left와 right를 사람 수의 min과 max로 잡으면 풀이가 가능했다.

class Solution {
    static int[] stones;
    static int k;
    
    public int solution(int[] stones, int k) {
        this.stones = stones;
        this.k = k;
        
        int answer = 0;
        int min = 1; 
        int max = 200000000;
	      
        while (min <= max) {
            int mid = (min + max) / 2;
            
            if (isPossible(mid)) {
                min = mid + 1;
                answer = Math.max(answer, mid);
            } else {
                max = mid - 1;
            }
        }
        
        return answer;
    }
    
    boolean isPossible(int friends) {
      	int skip = 0;
        
        for (int stone : stones) {
            if (stone - friends < 0) {
                skip++;
            }
            else {
                skip = 0;
            }
            
            if (skip == k) {
                return false;
            }
        }
        
        return true;
    }
}

left와 right는 거리 또는 위치를 기준으로 잡아야 한다는 생각이 있었던 것 같다..

[느낀점]

이분탐색을 할 때 left, right, mid는 꼭 거리나 위치가 아니어도 된다.

시간복잡도를 올리는 원인이 되는 값을 left, right, mid로 잡는 경우도 고려하자.

(이 문제에서는 사람 수를 left, right, mid로 잡았다.)

[백준] 1806번 부분합 자바(Java)

한 면만 쓴 종이 — Tue, 25 Mar 2025 17:33:14 +0900

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

전형적인 투포인터 문제다.

투포이터는 O(N)의 시간복잡도를 갖는다. 시간제한이 0.5초인 이 문제에 사용하기 딱이다. ~~(사실 자바는 1초 제한.. ㅠ)~~

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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int S = Integer.parseInt(st.nextToken());
        int[] arr = new int[N + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

        int left = 0;
        int right = 0;
        int sum = 0;
        int ans = Integer.MAX_VALUE;

        while (right <= N && left >= 0) {
            if (sum >= S) {
                ans = Math.min(ans, right - left);
                sum -= arr[left++];
            } else {
                sum += arr[right++];
            }
        }
        
        if (ans == Integer.MAX_VALUE) {
            ans = 0;
        }
        System.out.println(ans);
    }
}

[기억하자]

투 포인터

- O(n) 의 시간복잡도를 가진다.

- 구간합, 부분합 연산에 사용하기 적합하다.

- 이름이 비슷한(?) 이분탐색과는 차이가 크다. 투 포인터는 보통 연속된 구간의 특성을 활용하여 조건을 만족하는 구간을 찾고, 이분탐색은 특정 값을 찾기 위해 많이 사용되는 알고리즘이다.

[프로그래머스] 이모티콘 할인행사

한 면만 쓴 종이 — Mon, 24 Mar 2025 21:49:30 +0900

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

쌩구현 문제였다.

[풀이한 코드]

import java.util.*;

class Solution {
        static final Map<Integer, Integer> percentMap = Map.of(10, 9, 20, 8, 30, 7, 40, 6);
    static final int[] pers = new int[]{10, 20, 30, 40};
    
    static int[][] users;
    static int[] emoticons;
    static int maxPlusUser;
    static long maxSale;
    
    public int[] solution(int[][] users, int[] emoticons) {        
        this.users = users;
        this.emoticons = emoticons;
        int[] percents = new int[emoticons.length];
        makePercents(0, percents);
        
        return new int[]{maxPlusUser, (int) maxSale};
    }
    
    private void makePercents(int cnt, int[] percents) {
        if (cnt == emoticons.length) {
            event(percents);
            return;
        }
        
        for (int i = 0; i < 4; i++) {
            percents[cnt] = pers[i];
            makePercents(cnt + 1, percents);
        }
    }
    
    private void event(int[] percents) {
        // 이모티콘 구매자
        List<Integer>[] emoticonBuyers = makeEmoticonBuyers(percents);
        
        // 할인된 이모티콘 가격
        int[] emoticonPrices = new int[percents.length];
        for(int i = 0; i < percents.length; i++) {
            emoticonPrices[i] = emoticons[i] / 10 * percentMap.get(percents[i]);
        }
        
        // 사용자별 구매 가격 계산 (이모티콘 플러스 고려 전)
        long[] totalPricesPerUsers = new long[users.length];
        for (int i = 0; i < percents.length; i++) {
            List<Integer> buyers = emoticonBuyers[i];
            for (int buyer : buyers) {
                totalPricesPerUsers[buyer] += emoticonPrices[i];
            }
        }
        
        // 이모티콘 플러스 가입자 수
        boolean[] isPlusUser = new boolean[users.length];
        int plusUserCnt = 0;
        for (int i = 0; i < users.length; i++) {
            if (totalPricesPerUsers[i] >= users[i][1]) {
                isPlusUser[i] = true;
                plusUserCnt++;
            }
        }
        if (maxPlusUser > plusUserCnt) {
            return;
        }
        
        // 이모티콘 플러스 고려하여 판매액 계산
        long totalPrice = 0L;
        for (int i = 0; i < users.length; i++) {
            if (!isPlusUser[i]) {
                totalPrice += totalPricesPerUsers[i];
            }
        }
        if (maxPlusUser < plusUserCnt) {
            maxPlusUser = plusUserCnt;
            maxSale = totalPrice;
        } else {  // maxPlusUser == plusUserCnt 인 경우
            maxSale = Math.max(maxSale, totalPrice);  
        }
    }
    
    static List<Integer>[] makeEmoticonBuyers(int[] percents) {
        List<Integer>[] emoticonBuyers = new ArrayList[percents.length];
        for (int i = 0; i < percents.length; i++) {
            int percent = percents[i];
            emoticonBuyers[i] = new ArrayList<>();
            for (int j = 0; j < users.length; j++) {
                if (percent >= users[j][0]) {
                    emoticonBuyers[i].add(j);
                }
            }
        }
        return emoticonBuyers;
    }
}

13, 15, 18번 테스트케이스에서 틀렸었다.

부동 소수점연산은 근사값을 저장하기 때문에 이모티콘의 할인된 가격을 계산하면서 틀린 것이다.

[기존 코드]

static final Map<Integer, Double> percentMap = Map.of(10, 0.9, 20, 0.8, 30, 0.7, 40, 0.6);

```

private void event(int[] percents) {
    ```
    // 할인된 이모티콘 가격
    int[] emoticonPrices = new int[percents.length];
    for(int i = 0; i < percents.length; i++) {
        emoticonPrices[i] = (int) (emoticons[i] * percentMap.get(percents[i]));
    }
    ````
}

위 코드에서 percentMap.get(percents[i]) 를 사용해서 곱셈을 하면 double 즉, 실수값이 반환된다. 하지만, 이는 결과값이 5400 이었어도 5400.0000001 이 저장되었을 수도 있다.

그래서 모조리 정수 연산으로 바꾸어서 계산하도록 수정했다.

[수정한 코드]

static final Map<Integer, Integer> percentMap = Map.of(10, 9, 20, 8, 30, 7, 40, 6);

```

private void event(int[] percents) {
    ```
    // 할인된 이모티콘 가격
    int[] emoticonPrices = new int[percents.length];
    for(int i = 0; i < percents.length; i++) {
        emoticonPrices[i] = emoticons[i] / 10 * percentMap.get(percents[i]);
    }
    ````
}

percentMap에 저장되는 타입을 <Integer, Integer> 으로 수정하고, emoticons[i] / 10 * percentMap.get(percents[i]) 처럼 정수만 사용하도록 수정했다.

[기억하자]

실수연산을 할 때는 부동소수점의 오류를 주의하자. 3.2 를 저장했어도 실제로는 3.20000000001 이 저장되어 추후 결과값이 완전히 달라질 수 있다.

따라서 다음과 같은 해결책으로 부동소수점의 오류를 피하자.

최대한 정수로 연산하기
- 10 * 0.8 -> 10 / 10 * 8 처럼 정수만을 사용하도록 수정
Math.round(v)
- Math.round() 를 해주면 소수점 첫째 자리까지 반올림해준다.

그리고 이중 (혹은 그 이상의) for 문을 사용하고, 각각 인덱싱을 위한 변수로 쓰인다면 올바른 배열 혹은 리스트에 해당 인덱싱이 쓰였는지 조심!!하자.

[프로그래머스] 표현 가능한 이진 트리 자바

한 면만 쓴 종이 — Wed, 19 Mar 2025 20:41:52 +0900

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

분할정복을 사용하는 문제입니다.

[풀이한 코드]

import java.util.*;

class Solution {
    public int[] solution(long[] numbers) {
        int[] answer = new int[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            answer[i] = getAnswer(numbers[i]);
        }
        return answer;
    }
    
    static int getAnswer(long number) {
        // 1) 십진수 -> 이진수 변환
        String binary = Long.toBinaryString(number);
        
        // 2) 이진수에 더미 노드 채우기
        double size = getSize(binary.length());
        StringBuilder add = new StringBuilder();
        for (int i = binary.length(); i < size; i++) {
            add.append("0");
        }
        binary = add.toString() + binary;
        
        // 3) 만든 트리가 올바른 트리인지 확인하기
        if (isBinaryTree(binary)) {
            return 1;
        }
        return 0;
    }
    
    static int getSize(int length) {
        int h = 1;
        while((int) Math.pow(2, h) - 1 < length) {
            h++;
        }
        return (int) Math.pow(2, h) - 1;
    }
    
    static boolean isBinaryTree(String tree) {
        int len = tree.length();
        if (tree.length() == 0) {
            return true;
        }
        
        int root = len / 2;
        String leftSubTree = tree.substring(0, root);
        String rightSubTree = tree.substring(root + 1);
        if (tree.charAt(root) == '0') {
            return isZeroTree(tree.substring(0, root)) && isZeroTree(tree.substring(root + 1));
        }
        return isBinaryTree(leftSubTree) && isBinaryTree(rightSubTree);
    }
                                                                    
    static boolean isZeroTree(String tree) {
        int len = tree.length();
        if (tree.length() == 0) return true;

        int root = len / 2;
        String leftSubTree = tree.substring(0, root);
        String rightSubTree = tree.substring(root + 1);

        if (tree.charAt(root) == '1') {
            return false;
        }

        return isZeroTree(leftSubTree) && isZeroTree(rightSubTree);
    }
}

[기억하자]

1. 포화 이진 트리의 노드 수: 2 ^ (h + 1)) - 1

- 루트 노드의 레벨을 0이라고 생각했을 때의 공식이다.

- 루트 노드의 레벨을 1이라고 생각하면 2 ^ h - 1 이다.

- 자바로 하면, (int) Math.pow(2, h) - 1 < length 이다. Math.pow() 의 반환값은 double 이기 때문에 (int) 로 강제 형변환할 수 있다.

2. Long.toBinaryString(num)

- Integer.toBinaryString(num)도 가능하다.

- 이진수로 변환해준다.

3. String.substring(int st, int en)

- string의 s는 대문자가 아니라 소문자이다!

4. 트리에서 분할정복 방법

- 트리를 오른쪽 트리와 왼쪽 트리로 나눈다.

- 왼쪽 트리와 오른쪽 트리를 재귀함수로 다시 넣어서 반복한다.

private static boolean dfs(String number) {
    boolean valid = true;

    int mid = (number.length()-1)/2;
    char root = number.charAt(mid);
    String left = number.substring(0,mid);
    String right = number.substring(mid+1,number.length());

    if(root == '0' && (left.charAt((left.length()-1)/2)=='1' || right.charAt((right.length()-1)/2)=='1')){
        return false;
    }
    
    valid = dfs(left);
    if (valid) {
        valid = dfs(right);
    }

    if(left.length() >= 3) {  // 리프노드는 0이어도 상관없기 때문에 길이가 3이상일 때만 탐색
        valid = dfs(left);
        if(valid) {
            valid = dfs(right);
        }
    }
    return valid;
}

[백준] 우주신과의 교감 1774번 자바

한 면만 쓴 종이 — Wed, 19 Mar 2025 13:37:19 +0900

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

기본적인 MST 문제입니다.

최소신장트리

그래프의 모든 정점을 사이클 없이 잇는 트리에서 간선의 가중치의 합이 최소가 되는 트리

크루스칼 알고리즘

간선을 하나씩 늘려가면서 이어줍니다.

[풀이한 코드]

package mst;

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

public class B1774 {
    static class Node {
        int x;
        int y;
        Node(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    static class Edge implements Comparable<Edge> {
        int a;
        int b;
        double dist;
        public Edge(int a, int b, double dist) {
            this.a = a;
            this.b = b;
            this.dist = dist;
        }

        @Override
        public int compareTo(Edge o) {
            return Double.compare(this.dist, o.dist);
        }
    }
    static int[] parents;
    static Node[] nodes;
    static int N;
    static int M;

    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());
        nodes = new Node[N + 1];
        parents = new int[N + 1];
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            int x = Integer.parseInt(st.nextToken());
            int y = Integer.parseInt(st.nextToken());
            nodes[i + 1] = new Node(x, y);
            parents[i + 1] = i + 1;
        }

        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            unionParent(a, b);
        }

        PriorityQueue<Edge> pq = new PriorityQueue<>();
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                double cost = Math.sqrt(Math.pow(nodes[i].x - nodes[j].x, 2) + Math.pow(nodes[i].y - nodes[j].y, 2));
                pq.add(new Edge(i, j, cost));
            }
        }
        double cost = 0;
        while (!pq.isEmpty()) {
            Edge edge = pq.poll();
            if (findParent(edge.a) != findParent(edge.b)) {
                unionParent(edge.a, edge.b);
                cost += edge.dist;
            }
        }
        System.out.printf("%.2f", cost);
    }

    static void unionParent(int a, int b) {
        a = findParent(a);
        b = findParent(b);
        if (a < b) {
            parents[b] = a;
        } else {
            parents[a] = b;
        }
    }

    static int findParent(int x) {
        if (parents[x] == x) {
            return x;
        }
        return parents[x] = findParent(parents[x]);
    }
}

[시간복잡도]

1. 이미 연결된 간선 처리

- M개의 이미 연결된 간선을 처리합니다.

- 이때, Union Find 알고리즘을 사요했습니다. 해당 알고리즘은 O(1)에 가까운 시간복잡도를 갖습니다.

2. 모든 노드 간 거리를 우선순위 큐에 삽입

- 우선순위 큐에 삽입하는 연산: O(logN)

-> 이중 반복문을 돌리며 우선순위 큐에 삽입하는 연산: O(N^2 logN)

3. 크루스칼 알고리즘

- 우선순위 큐에서 poll() 연산: O(logN)

- unionParent() 연산: O(1) 에 가까움

-> N^2 번 수행

-> O(N^2 logN)

따라서 최종 시간복잡도는 O(N^2 logN) 입니다.

[기억하자]

1. inner class 의 비교 방법

- Comparable<Edge> 를 implements하기

- @Override public int compareTo() 구현

static class Edge implements Comparable<Edge> {
    int a;
    int b;
    double dist;
    public Edge(int a, int b, double dist) {
        this.a = a;
        this.b = b;
        this.dist = dist;
    }

    @Override
    public int compareTo(Edge o) {
        return Double.compare(this.dist, o.dist);
    }
}

2. 제곱할 때 x * x는 오버플로 발생 가능성이 있기 때문에 Math.pow() 사용하기

- 단, 반환값은 항상 double이다.

- Math.pow(x, 2) 를 하면 x의 2제곱

3. 출력할 때 소수점 2번째 자리까지 반올림하기

- System.out.printf("%.2f", 수);

Mac에 Oracle 19c 버전 설치 (ORA-12526 오류 해결)

한 면만 쓴 종이 — Tue, 25 Feb 2025 23:54:25 +0900

제 맥은 M2 칩입니다.

[1] Colima 설치

[1-1] colima를 설치합니다.

$ brew install colima

사전에 brew가 설치되어 있어야 합니다.

[1-2] Colima를 실행합니다.

$ colima start --memory 4 --arch x86_64

→ $ docker context ls 명령을 통해 colima 옆에 * 표시로 실행되고 있는지 확인해야 합니다.

[2] oracle-19c 설치하기

[2-1] docker image pull 받기

$ docker pull doctorkirk/oracle-19c

docker images 명령어를 통해 받은 이미지를 확인하실 수 있습니다.

[3] 디렉토리 생성

[3-1] 디렉토리 이동

$ mkdir -p /{내가 원하는 디렉토리}/oracle-19c/oradata

이후 /{내가 원하는 디렉토리} 로 이동합니다.

[3-2] 소유자 변경

$ sudo chown -R 54321:54321 .oracle-19c

[4] 컨테이너 만들기

    docker run --name oracle-19c \\
    -p 1521:1521 \\
    -e ORACLE_SID=ORCL \\
    -e ORACLE_PWD=1234 \\
    -e ORACLE_CHARACTERSET=KO16MSWIN949 \\
    -v /**{내가 원하는 디렉토리}**/oracle-19c/oradata/:/opt/oracle/oradata doctorkirk/oracle-19c

이걸 하면 아마 시간이 아 좀 너무한데? 싶을 정도로 오래 걸리는 분이 계실 겁니다.

그때는 docker ps 명령을 통해 실행중인 컨테이너를 확인합니다.

명령을 통해 나온 STATUS 컬럼값의 괄호 안 값이 health: starting 이면 아직 더 기다리셔야 합니다.

하지만, healthy 이면 그냥 다음 단계로 이동하셔도 좋습니다.

저는 새로 터미널 창을 열어서 진행했습니다. 컨테이너 생성중이라던 터미널은 아직도 저러고 있네요..

[5] Bash로 접속해서 SQL 명령

[5-1] $ docker exec -it oracle-19c bash

bash 로 컨테이너를 접속해줍니다.

[5-2] oracleDB에 사용자 생성

	ALTER SESSION SET "_ORACLE_SCRIPT"=true;
    
  CREATE USER oracleuser identified by oraclepassword;  #username과 password는 원하는거 하십쇼
  
  grant connect, resource to oracleuser;
  
  alter user oracleuser quota unlimited on users;

[6] DBeaver에서 연결

[6-1] DBeaver 설치

https://dbeaver.io/download/

위 링크에 들어가셔서 Mac OS X 를 설치합니다. 저는 그 중 `MacOS for Apple Sillicon (dmg) 라고 적혀 있는 것을 다운 받았습니다.

이후에는 dmg 파일 풀어서 Applications에 넣으라면 넣고 실행하면 됩니다.

[6-2] Oracle DB 연결하기

DBeaver에서 설치하란 것은 전부 설치해줬습니다. 설치 안한다 했더니 오류를 뱉더라고요..

가장 왼쪽 상단의 콘센트 모양을 클릭하여 Connect to a database 창에서 Oracle을 선택해줍니다.

이렇게 설정해줍니다. 특히 Database 줄에서 SID로 변경해주는 것 잊으시면 안됩니다.

이러고 Test Connection을 해줍니다. 저는 이때 매우 콩닥거렸죠. 그리고 절망했습니다.

만약 다음과 같은 오류가 뜨는 분이 계신다면 침착하세요.

ORA-12526: TNS:리스너: 적절한 모든 인스턴스가 제한 모드입니다.

이전에 sqlplus에 접속했던 터미널 창으로 돌아갑니다. 그리고 다음 명령어를 입력하세요.

SELECT LOGINS FROM V$INSTANCE;

그럼 RESTRICTED라고 뜰겁니다.

ALTER SYSTEM DISABLE RESTRICTED SESSION; 입력하고 다시 Test Connection 하면 아래와 같이 정상적으로 뜰겁니다.

읽어주셔서 감사하고 도움이 되셨길 바랍니다!

그럼 2만~

ps. 오류가 난다면 모두 지우고 처음부터 다시 시도해 보세요..

저는 5번정도 ^^ 시도한 것 같습니다..

그리고 제가 기재한 모든 과정을 !!똑같이!! 하시길 추천드립니다.

아.. 이건 아닌 것 같은데.. 라는 생각으로 몇 과정을 조금씩 수정하다가는.. 저처럼 5번….을 하게 되실 수 있습니다.

[참고]

https://lovethefeel.tistory.com/124

https://velog.io/@ccorgi1997/Mac-M1-%EB%A7%A5%EB%B6%81%EC%97%90%EC%84%9C-Oracle-11-%EC%82%AC%EC%9A%A9%ED%95%98%EA%B8%B0

https://hard-carry.com/way-to-install-oracledb-on-silicon-mac-m2

브라우저에 네이버 URL을 입력했을 때 벌어지는 일

한 면만 쓴 종이 — Sun, 16 Feb 2025 22:38:52 +0900

[요약]

URL 파싱 → 캐싱된 DNS 기록 확인 → DNS 조회
라우터를 통해 해당 서버의 게이트웨이까지 이동 -> ARP를 통해 IP 주소를 MAC 주소로 변환 네이버 서버 도달
대상 서버와 TCP 소켓 연결 -> HTTP(HTTPS) 프로토콜 요청 & 응답 -> 브라우저에서 응답 해석해서 보여준다!

[1] URL 파싱

프로토콜, 호스트 이름, 경로, 포트 등으로 URL의 구조를 해석합니다.
이때 파싱한 호스트 이름을 캐싱된 DNS 기록 확인 단계에서 사용합니다.

[2] 캐싱된 DNS 기록 확인

브라우저는 DNS 해석 과정을 단축하기 위해 캐싱된 DNS 기록을 먼저 확인합니다.
캐시에 IP주소가 존재하면, DNS 쿼리를 추가하지 않고, 바로 연결을 시도합니다.
- 브라우저 캐시 -> OS 캐시 -> 라우터 캐시 -> ISP 캐시 순서로 확인합니다.

[3] DNS 조회

캐시에 해당 URL(호스트 네임)이 존재하지 않으면, DNS 서버에 요청해 해당 URL을 IP 주소로 변환합니다.
이때 DNS란, 도메인 이름과 IP 주소를 매핑해주는 서버입니다.
[DNS 서버로 요청하는 과정]
[Root DNS] → [.com DNS] → [.naver DNS] → [.www DNS]
위와 같은 과정을 거쳐 완벽한 주소를 찾아 IP 주소를 매핑합니다.

[4] 라우터를 통해 해당 서버의 게이트웨이까지 이동

*게이트웨이: 서로 다른 통신망, 프로토콜을 사용하는 네트워크 간의 통신을 가능하게 하는 컴퓨터나 SW를 두루 일컫는 용어
DNS 서버한테 IP 주소를 받았으니 해당 서버로 요청을 보냅니다.
이 요청은 네트워크 장비인 라우터의 라우팅을 통해 네트워크를 타고 이루어집니다.
각각의 라우터에 있는 라우팅 테이블의 IP를 기반으로 패킷을 전달해 나갑니다.

[5] ARP를 통해 IP 주소를 MAC 주소로 변환

*ARP: IP 주소로부터 MAC 주소를 구하는 IP와 MAC 주소의 다리 역할을 하는 프로토콜
실질적인 통신을 하기 위해서는 논리 주소인 IP 주소를 물리 주소인 MAC 주소로 변환해야 합니다.
이를 위해 해당 네트워크 내에서 ARP 요청을 브로드캐스팅합니다.
해당 IP 주소를 가지고 있는 서버는 자신의 MAC 주소를 응답합니다.

이로써 실제 네이버의 서버에 도달하게 됩니다!

[6] 대상 서버와 TCP 소켓 연결

찾은 대상 서버와 통신하기 위해 TCP 소켓 연결을 진행합니다.
소켓 연결은 3-way handshake 과정을 통해 이루어집니다.
HTTPS 요청인 경우 암호화 통신을 위한 TLS 핸드쉐이킹을 추가합니다.

[7] HTTP(HTTPS) 프로토콜 요청 & 응답

연결이 되었으니 해당 페이지(www.naver.com)를 달라고 서버에 요청합니다.
서버는 요청에 대한 응답을 생성하여 브라우저에 전달합니다.

[8] 브라우저에서 응답 해석

서버의 응답 내용은 HTML, CSS, Javascript 등으로 이루어져 있습니다.
따라서 일반 사용자도 볼 수 있도록 이를 해석하여 페이지를 보여주게 됩니다!

최근에 면접을 봤습니다. 해당 기업에서 정말 많은.. 질문을 받았습니다. 2:1 면접이었는데 1시간 넘게.. 봤어요..
30분 넘어가니까 목이 건조해져서 말하다가 쇳소리까지 났습니다. (+ 긴장해서 목탄것두 잇서용 ㅎㅎ)
아무튼 CS 관련 질문도 매우 많이 받았고.. 제대로 대답하지 못한 질문도 많았어요. 많이 아쉽지만 CS 공부를 더 열심히 하게 된 계기가 되었습니다 :) 굳

PriorityQueue forEach() 는 정렬되어 조회되지 않는다?!

한 면만 쓴 종이 — Thu, 13 Feb 2025 23:18:11 +0900

오늘의 주제는

PriorityQueue의 forEach 메서드의 조회 순서

입니다.

여느때와 같이 알고리즘 문제를 풀고 있었는데..

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

- 문제 보고 오세용

자꾸 내 코드가 맞는데 틀렸다고~ 틀렸다고~ 하는거 아닙니까.

진심으로다가 집 가야되는데 계속 틀렸다니까 집도 못 가고! 밥도 못 먹고! ㅠㅠ

아무튼 제가 작성했던 답은 아래와 같습니다.

여러분들을 위해 주석을 꼼꼼히 달아봤어용.

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

public class Main {
    // 종료 시간 기준 후보
    static PriorityQueue<int[]> timeCandis = new PriorityQueue<>((c1, c2) -> c1[0] - c2[0]);  // 종료 시간, 좌석 번호
    // 테이블 번호 기준 후보
    static PriorityQueue<int[]> tableCandis = new PriorityQueue<>((c1, c2) -> c1[1] - c2[1]);  // 종료 시간, 좌석 번호

    public static void main(String[] args) throws IOException {
    	// 입력
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        StringBuilder sb = new StringBuilder();
        int N = Integer.parseInt(br.readLine());
        List<int[]> times = new ArrayList<>();  // 시작 시간, 종료 시간
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            times.add(new int[]{Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken())});
        }
        
        // 싸지방 사용 시간 정렬 (시작 시간 기준)
        times.sort(Comparator.comparingInt(t -> t[0]));

        int idx = 0;
        int[] tables = new int[N];  // 자리 사용 횟수 저장 배열
        tables[idx]++;
        timeCandis.add(new int[]{times.get(0)[1], idx++});

        for (int i = 1; i < N; i++) {
            int[] now = times.get(i);
            // 시간 변경 + 사람 더 앉음 -> time & table candidates 다시 검사해줌
            checkEndTime(now[0]);

            // idx 전에 빈 자리가 있으면 해당 자리에 앉힘
            // 사람이 앉으면 timeCandis에 무조건 넣음
            if (!tableCandis.isEmpty()) {
                int[] candi = tableCandis.poll();
                timeCandis.add(new int[]{now[1], candi[1]});
                tables[candi[1]]++;
            } else {  // idx 전에 빈 자리 없으면 idx에 앉히고 하나 늘림
                tables[idx]++;
                timeCandis.add(new int[]{now[1], idx});
                idx++;
            }
        }
		
        // 출력
        sb.append(idx).append("\n");
        for (int i = 0; i < idx; i++) {
            sb.append(tables[i]).append(" ");
        }
        System.out.println(sb);
    }

    static void checkEndTime(int now) {
        int cnt = 0;
        // 우선순위 큐인 timeCandis에서 하나씩 조회 -> 종료 시간이 현재 시간보다 적은 것.
        // 즉, 이미 사용 종료된 자리 정보는 사용 가능한 자리이기 때문에 tableCandis에 넣음
        // tableCandis에 넣은 만큼 timeCandis에서 빼기위해 cnt 세줌.
        for (int[] time : timeCandis) {
            if (time[0] < now) {
                tableCandis.add(time);
                cnt++;
            } else {
                break;
            }
        }
        // cnt 만큼 timeCandis에서 빼줌
        for (int i = 0; i < cnt; i++) {
            timeCandis.poll();
        }
    }
}

중요한 부분은 checkEndTime 메서드입니다.

저는 우선순위 큐를 forEach로 조회하면 우선순위대로 (순서대로) 조회될 거라고 생각했습니다.

하지만 PriorityQueue를 forEach는 순서대로 조회되지 않습니다..

이제 그 이유를 알아보겠습니당.

PriorityQueue의 forEach메서드를 보겠습니다.

es라는 배열을 순서대로 조회하는데 es는 queue네요.

그럼 이제 queue를 보겟슴다.

저같은 사람을 위해 상세하게 주석 설명이 있네요.. 고마워라

가장 작은 값(우선순위 0번째)의 인덱스가 0인 것은 맞습니다.

하지만 제가 간과한 부분! 우선순위 큐는 힙이기 때문에 완전 이진 트리 구조입니다.

오름 차순을 정렬 기준으로 했을 때, 부모 노드는 자식 노드보다 클 수 없죠.

이것은 트리를 순서대로 방문하면 되는 완전히 정렬된 상태는 아니라는 것을 뜻합니다. (첫 노드는 최솟값이라는 것은 보장 가능. 무조건 보장!)

또한, 위의 설명에 있듯이 queue 배열은 그저 트리를 배열에 담은 것 뿐입니다. 순서대로 말이죠.

그러니까 queue[n]의 자식이 queue[2 * n + 1]과 queue[2 * (n + 1)] 인 것이죠.

저는 우선순위 큐 자료구조의 특성은 제끼고 그냥 아~ 우선순위니까 차례대로 조회하게 해주겠지~ .... 라고 생각하고 위와 같은 코드를 짜게 됐던 것입니다. 허허 뭐든 잘 알고 사용하는게 정말정말.. 중요하죠

그럼 제가 짠 코드를 고쳐봐야겠죠잉?

public class Main {
    // 종료 시간 기준 후보
    static PriorityQueue<int[]> timeCandis = new PriorityQueue<>((c1, c2) -> c1[0] - c2[0]);  // 종료 시간, 좌석 번호
    // 테이블 번호 기준 후보
    static PriorityQueue<int[]> tableCandis = new PriorityQueue<>((c1, c2) -> c1[1] - c2[1]);  // 종료 시간, 좌석 번호

    public static void main(String[] args) throws IOException {
        ```
    }

    static void checkEndTime(int now) {
        while (!timeCandis.isEmpty()) {
            int[] time = timeCandis.peek(); // [1]
            if (time[0] < now) {
                tableCandis.add(time);
                timeCandis.poll();  // [2]
            } else {
                break;  // [3]
            }
        }
    }
}

[1] peek()로 timeCandis의 첫 노드. 즉, 종료 시간이 가장 빠른 노드를 가져옵니다. 이 종료 시간이 현재 시간 이전이면 해당 자리는 빈 자리인 것이죠

[2] 그럼 해당 노드는 빼줘야 합니다. 왜냐? tableCandis에 넣어줘야 하거든요. 여기는 비어있는 자리를 저장하는 우선순위 큐 공간이랍니다.

[3] 만약 timeCandis에서 peek()로 조회한 종료 시간이 가장 빠른 노드가 현재 시간보다 이후 시간이면 더이상 해당 큐에는 현재 시간보다 빠른 노드는 존재하지 않는 거겠죠잉? 그럼 그~냥 바로 해당 반복문을 탈출!하는겁니다.

이렇게 해서 백준 싸지방에 간 준하 문제는 해결되었습니다. 짜란~

정말.. 다양한.. 시도들을 해봤어요.. 이건가? 하면서 고치다가 시간초과까지 나버림. 하핫

정말 왜 통과 못하는지 도무지 모르겠었는데 해결해서 기분이 좋네용. 햅삐~

[Django] 프로젝트 만들기

한 면만 쓴 종이 — Fri, 3 Jan 2025 04:06:28 +0900

[1] 프로젝트 생성하기

1. 깃허브에 레포를 하나 팠다.

2. 해당 레포를 클론받고, 터미널에서 클론받은 로컬 위치로 이동한다.

3. `python3 -m venv venv` 를 입력한다. (두번째 venv는 본인이 지정하면 된다.)

4. `source venv/bin/activate` 를 입력한다. 이를 통해 가상환경을 활성화한다.

5. `pip install django djangorestframework` 를 입력하여 drf 패키지를 설치한다.

6. `django-admin startproject myapi .` 를 입력하여 프로젝트를 생성한다.

ls 를 입력하여 확인해보면 아래와 같이 폴더가 생성된 것을 확인할 수 있다.

7. 장고를 설치한다. 새로운 터미널을 열어서 `pip install django` 를 입력한다.

8. `pip list` 를 입력하여 Django 가 있는지 확인한다.

9. 다시 프로젝트가 있는 터미널로 이동하여 `python manage.py startapp backend` 를 입력하여 앱을 만든다.

10. 이제 해당 경로를 IDE에서 열어서 개발하면 된다.

[2] 기본 설정

1. settings.py에서 ALLOWED_HOSTS 를 모두 열어준다.

ALLOWED_HOSTS = ['*']

2. settings.py에서 TIME_ZONE 을 한국으로 변경한다.

TIME_ZONE = "Asia/Seoul"

3. settings.py에서 STATIC_URL 밑에 아래 코드를 추가한다. 이를 통해 정적 파일 관리에 대한 선언을 한 것이다.

STATIC_URL = "static/"
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')

4. settings.py에서 INSTALLED_APPS 에 이전에 만든 "backend" 와 "rest_framework"를 추가한다.

INSTALLED_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "backend",
    "rest_framework",
]

5. 파이참에서 터미널을 열어서 `python manage.py makemigrations` 을 입력한다.

나는 이때 ModuleNotFoundError: No module named 'rest_framework' 이라는 오류가 났다.

찾아보니 가상환경에는 DRF가 설치되었는데 내 로컬에는 설치되어있지 않아서 이러한 오류가 뜨는 것 같았다. 그래서 로컬에도 `pip install django djangorestframework` 를 통해 설치했다.

이렇게 하니 아래와 같이 오류가 사라졌다.

6. 터미널에 `python manage.py makemigrations` 및 `python manage.py runserver` 를 입력한다.

그럼 다음과 같이 서버가 실행된 것을 볼 수 있다.