JK-LEE98

멀티테넌시(Multi-tenancy)란?

JK-LEE98 — Tue, 28 Jul 2026 09:45:57 +0900

멀티테넌시(Multi-tenancy)란?

멀티테넌시란?

멀티테넌시는 하나의 애플리케이션과 하나의 인프라(DB, 서버)를 여러 고객이 함께 쓰면서도, 각 고객의 데이터와 설정은 완전히 분리해서 관리하는 아키텍처다. 여기서 Tenant는 서비스를 사용하는 하나의 고객(회사·조직)을 말한다.

헬스장 회원관리 SaaS를 예로 들면 이런 구조가 된다.

회원관리 서비스
├── 헬스장 A
├── 헬스장 B
└── 헬스장 C

헬스장 A, B, C가 각각 Tenant다. 모두 같은 프로그램을 쓰지만 서로의 회원 정보는 절대 조회할 수 없다.

왜 멀티테넌시를 쓸까?

헬스장마다 서버와 DB를 따로 운영한다고 해보자.

헬스장 A → 서버 + DB
헬스장 B → 서버 + DB
헬스장 C → 서버 + DB

고객이 늘수록 비용이 폭발한다. 반면 멀티테넌시는 하나의 서버와 하나의 DB를 여러 고객이 나눠 쓴다.

회원관리 서비스
        │
   하나의 DB 서버
        │
 헬스장A  헬스장B  헬스장C

비용이 싸고 유지보수가 쉽다. SaaS에서 가장 많이 쓰는 방식이다.

데이터는 어떻게 분리될까?

가장 흔한 방식은 모든 테이블에 tenant_id를 넣는 것이다. member 테이블이라면 이렇게 된다.

id tenant_id name

1	gym_a	김철수
2	gym_a	이영희
3	gym_b	박민수

조회할 때는 항상 tenant_id 조건을 건다.

SELECT *
FROM member
WHERE tenant_id = 'gym_a';

그래서 gym_a 사용자는 gym_b 데이터를 절대 못 본다.

멀티테넌시 구현 방식

1. Shared Database, Shared Schema. 가장 많이 쓰는 방식이다. 하나의 DB에 모든 테이블을 두고, 각 테이블에 tenant_id 컬럼을 붙인다.

DB
member
trainer
payment
...

구현이 가장 간단하고, 비용이 가장 싸고, 운영이 쉽다. 대신 tenant_id 조건을 하나라도 빼먹으면 다른 고객 데이터가 새어 나간다.

2. Shared Database, Separate Schema. DB는 하나지만 스키마를 고객별로 나눈다.

DB
gym_a.member   gym_a.payment
gym_b.member   gym_b.payment

분리가 조금 더 안전한 대신 관리가 복잡해진다.

3. Separate Database. 고객마다 DB를 통째로 분리한다.

DB Server
gym_a_database
gym_b_database
gym_c_database

가장 안전하지만 비용도 가장 크다.

Role과 Tenant는 뭐가 다를까?

멀티테넌시를 처음 보면 제일 헷갈리는 부분이다. 결론부터 말하면 둘은 푸는 문제가 다르다.

Tenant는 "어느 고객의 데이터인가"를 다룬다. BBQ, BHC, 교촌이 같은 서비스를 쓴다고 하자. tenant = BBQ인 사용자는 BBQ 데이터만 봐야 하고, BHC나 교촌 데이터는 절대 조회하면 안 된다. 즉 Tenant는 고객 간 데이터 경계를 만드는 개념이다.

Role은 "같은 회사 안에서 누가 어디까지 보는가"를 다룬다. BBQ 안에도 본사, 영업팀, 물류팀, 가맹점이 있고 ROLE_ADMIN, ROLE_MANAGER, ROLE_FRANCHISE 같은 권한이 있다.

ROLE_ADMIN → BBQ 전체 조회
ROLE_MANAGER → 담당 가맹점 조회
ROLE_FRANCHISE → 자기 가맹점만 조회

즉 Role은 같은 Tenant 내부에서 권한을 나누는 개념이다.

둘은 함께 쓴다

JWT에 이렇게 담겨 있다고 하자.

{
  "tenantId": "BBQ",
  "role": "MANAGER"
}

조회는 두 단계로 간다. 먼저 tenant로 BBQ 데이터만 걸러내고, 그다음 Role로 범위를 좁힌다. ROLE_MANAGER면 담당 가맹점만 조회한다. 실제 순서는 Tenant → Role이다.

tenant_id만 있으면 Role은 필요 없을까?

아니다. tenant_id는 "다른 회사 데이터를 못 보게 하는 장치"고, Role은 "우리 회사 안에서 누가 어디까지 보는가"를 정한다. Tenant는 회사 간 분리, Role은 회사 내부 권한. 서로 대체하는 게 아니라 같이 쓰는 개념이다.

내가 만든 ERP는 멀티테넌시였을까?

내가 참여한 ERP는 본사 → 영업팀 → 가맹점 구조였고, 직급과 부서에 따라 조회 범위가 달랐다. 영업팀장은 모든 가맹점을, 담당자는 담당 가맹점을, 가맹점주는 자기 매장만 봤다. 데이터 접근 제한은 분명히 있었다. 하지만 이건 Role 기반 접근 제어(RBAC)다.

왜 멀티테넌시가 아니냐면, 그 ERP는 하나의 회사(BBQ)만을 위한 시스템이었기 때문이다. tenant는 BBQ 하나뿐이었다. 만약 이걸 BBQ, BHC, 교촌, 굽네에 다 팔아서 한 시스템에서 굴린다면 그때부터 tenant = BBQ, tenant = BHC 같은 개념이 생긴다. 그게 멀티테넌시다. 정리하면 내 ERP는 RBAC는 있었지만 멀티테넌시는 없었다고 보는 게 맞다.

멀티테넌시로 확장한다면?

기존 구조가 BBQ → 가맹점 → 회원이었다면, 멀티테넌시에서는 맨 앞에 회사(Tenant) 계층이 하나 더 붙는다.

Tenant(BBQ) → 가맹점 → 회원
Tenant(BHC) → 가맹점 → 회원

기존 구조 앞에 "회사"라는 층을 하나 얹는 것이다.

정리

Role과 멀티테넌시는 다른 개념이다. Role은 "누가 보는가", 멀티테넌시는 "어느 고객의 데이터인가"를 정한다. 실무에서는 대부분 tenant_id로 고객 데이터를 먼저 자르고, Role로 회사 내부 권한을 다시 자른다. 즉 Tenant → Role → Data 순서로 접근을 제어하는 게 일반적인 멀티테넌시 구조다.

[프로그래머스] 주식가격

JK-LEE98 — Fri, 10 Jul 2026 11:32:03 +0900

이 문제는 프로그래머스 LV2에 해당하는 코딩테스트 문제다.

'스택/큐'에 대한 개념이 아직 잘 잡혀있지 않아서 나는 문제를 처음 보고 이중for문을 사용하는 방식으로 접근했다.

아래 코드는 이중for문을 활용한 방식이다.

class Solution {
    public int[] solution(int[] prices) {
        int[] arr = new int[prices.length];
        
        for (int i=0; i<arr.length-1; i++) {
            int count = 0;
            
            for (int j = i+1; j<prices.length; j++) {
                count++;
                if (prices[i] > prices[j]) {
                    break;
                }
            }
            
            arr[i] = count;
        }
        
        return arr;
    }
}

그러나 이 로직의 시간복잡도는 O(n²) 이기 때문에 스택을 활용한 방식으로 접근하는 것이 더 좋다.

이중 for문은 각 원소마다 뒤의 모든 원소를 탐색한다. 따라서 이미 확인했던 원소를 또 확인하는 일이 반복된다.

반면 스택을 사용하면 아직 가격이 떨어지지 않은 인덱스만 관리하면 된다.

여기서 가장 중요한 점은 가격이 아니라 인덱스를 저장한다는 것이다.

문제에서 필요한 것은 가격 자체가 아니라 몇 초 동안 가격이 유지되었는지이다.

몇 초가 유지되었는지는

현재 인덱스 - 이전 인덱스

로 계산할 수 있다.

따라서 가격만 저장해서는 몇 초가 지났는지 계산할 수 없으며, 반드시 인덱스를 저장해야 한다.

가격은 필요할 때마다

prices[index]

로 언제든지 확인할 수 있다.

예제

prices = [1, 2, 3, 2, 3]

스택은 비어있는 상태다.

i=0

현재 가격은 1이다.

스택이 비어 있으므로 비교할 대상이 없다.

따라서 현재 인덱스(0)를 스택에 넣는다.

i=1

현재 가격은 2이다.

스택의 맨 위에는 인덱스 0이 있다.

가격을 비교하면 현재 가격이 더 크므로 아직 가격이 떨어지지 않았다.

따라서 인덱스 1을 스택에 넣는다.

i=2

현재 가격은 3이다.

스택의 맨 위는 인덱스 1이다.

비교하면 가격이 떨어지지 않았다.

인덱스 2를 스택에 넣는다.

i=3

현재 가격은 2이다.

스택의 맨 위는 인덱스 2이다.

비교하면 가격이 떨어졌다.

이제 인덱스 2의 답을 계산할 수 있다.

스택에서 꺼내면

index = 2

현재 위치는

i = 3

이므로

3 - 2 = 1초

가격이 유지되었다.

따라서

answer[2] = 1;

이 된다.

이후 스택의 다음 원소를 확인한다.

현재 스택의 맨 위는 인덱스 1이다.

가격이 떨어진 것이 아니므로 반복문을 종료하고 현재 인덱스(3)을 스택에 넣는다.

stack = [3, 1, 0]

i=4

현재 가격은 3이다.

스택의 맨 위는 인덱스 3이다.

가격이 떨어지지 않았으므로 인덱스 4를 스택에 넣는다.

stack = [4, 3, 1, 0]

모든 탐색이 끝났다.

탐색이 끝났는데도 스택에 원소가 남아 있다는 것은 끝까지 가격이 한 번도 떨어지지 않았다는 의미이다.

따라서 남아있는 인덱스들은

prices.length - 1 - index

만큼 가격이 유지된 것이다.

이 문제는 가격을 저장하는 문제가 아니라, 아직 가격이 떨어지지 않은 인덱스를 관리하는 문제이다.

import java.util.*;

class Solution {
    public int[] solution(int[] prices) {
        int[] answer = new int[prices.length];
        Deque<Integer> stack = new ArrayDeque<>();

        for (int i = 0; i < prices.length; i++) {

            while (!stack.isEmpty() && prices[stack.peek()] > prices[i]) {
                int index = stack.pop();
                answer[index] = i - index;
            }

            stack.push(i);
        }

        while (!stack.isEmpty()) {
            int index = stack.pop();
            answer[index] = prices.length - 1 - index;
        }

        return answer;
    }
}

최종 코드다.

[프로그래머스] 숫자 문자열과 영단어

JK-LEE98 — Tue, 7 Jul 2026 09:44:44 +0900

이런 유형의 문제를 처음 보면 머릿 속에 미리 one, two, three, four... 숫자에 해당하는 영단어를 미리 숫자와 매칭을 시켜놓고 들어가야 되나? for문을 이용해서 반복문을 돌릴 때 반복문 안에서 어떻게 단위(숫자 하나) 별로 자를 수 있지? 어떻게 영어로 된 부분을 숫자로 교체하지? 등등 다양한 고민이 생길 수 있다.

나 역시 그랬다.

이 문제는 별거 없다. 그냥 java에서 교체하는 함수 replace만 알고있으면 된다.

String 배열에 영단어들을 저장하고 반복문을 10번 돌리면 되는 문제다.

반복문이 한 번 돌 때마다 일치하는 것이 있다면 숫자로 대체되게끔 하는 것을 말한다.

내가 범했던 실수가 하나있다.

바로 for문 안에 if문을 사용했던 것이다.

"만약 words에 있다면 교체한다" 라는 로직을 사용하고 싶었던 것인데 그럴 필요가 전혀없었다.

java의 replace()라는 함수는 일치하는 것이 없을 경우 그냥 패스하기 때문이다.

또 하나 유의할 점이 있다.

replace함수의 특성상 두 번째로 와야하는 것은 문자열이어야 한다.

따라서 i가 아닌 i+"" 를 사용하여 문자열 형태로 써야 한다.

최종 코드다

class Solution {
    public int solution(String s) {
        String[] words = {"zero", "one", "two", "three", "four", "five", "six"
                            , "seven", "eight", "nine"};
        
        for (int i=0; i<words.length; i++) {
            s = s.replace(words[i], i+"");
        }
        
        int answer = Integer.parseInt(s);
        
        return answer;
    }
}

[프로그래머스] 푸드 파이트 대회

JK-LEE98 — Sun, 5 Jul 2026 15:47:09 +0900

이 문제는 딱히 중요해 보이진 않았지만 reverse()라는 존재를 잊지 않기 위해 블로그에 남긴다.

사실 나는 reverse()를 사용하지 않았을 뿐더러 불필요한 arr배열까지 만들어서 반복해야 하는 수를 담기 까지 했는데

가장 정제된 코드로 reverse()를 사용했을 때와 안 했을 때를 비교해보자.

class Solution {
    public String solution(int[] food) {
        StringBuilder sb = new StringBuilder();

        // 왼쪽
        for (int i = 1; i < food.length; i++) {
            for (int j = 0; j < food[i] / 2; j++) {
                sb.append(i);
            }
        }

        // 물
        sb.append(0);

        // 오른쪽
        for (int i = food.length - 1; i >= 1; i--) {
            for (int j = 0; j < food[i] / 2; j++) {
                sb.append(i);
            }
        }

        return sb.toString();
    }
}

이건 사용하지 않았을 때다. arr을 제거한 대신 범위에 food[i] / 2를 사용한 것이다.

class Solution {
    public String solution(int[] food) {
        StringBuilder left = new StringBuilder();

        // 왼쪽만 생성
        for (int i = 1; i < food.length; i++) {
            for (int j = 0; j < food[i] / 2; j++) {
                left.append(i);
            }
        }

        // 오른쪽은 왼쪽을 뒤집어서 생성
        StringBuilder right = new StringBuilder(left).reverse();

        return left.append(0).append(right).toString();
    }
}

이렇게 하면 유사하지만 반대로 동작하는 반복문을 사용할 필요가 없어진다.

left를 만들고 left를 뒤집은 right를 정의한 후 return할 때 left + 0 + right 하면 더 간단한 코드를 완성시킬 수 있다.

[프로그래머스] 시저 암호

JK-LEE98 — Tue, 30 Jun 2026 03:33:49 +0900

이 문제는 프로그래머스 LV1 단계에 해당하는 시저 암호 문제다.

복잡한 알고리즘을 요구하는 문제는 아니지만, 문자의 코드값(ASCII/Unicode)과 문자 연산을 이해하는 데 도움이 되는 문제라고 생각해 정리해 보았다.

Java의 char는 Unicode를 사용하지만, 영문 알파벳(A~Z, a~z)의 코드값은 ASCII와 동일하다. 따라서 시저 암호와 같은 문제에서는 ASCII 코드의 개념으로 이해해도 무방하다. 문자도 내부적으로는 숫자로 저장되기 때문에 숫자처럼 덧셈과 뺄셈 연산을 할 수 있다.

따라서 이 문제는 영문 알파벳이 연속된 코드값을 가진다는 점과, 문자를 숫자처럼 더하고 뺄 수 있다는 점을 이용해 해결할 수 있다.

문자	코드	'A'를 뺀 결과
A	65	0
B	66	1
C	67	2
...	...	...
X	88	23
Y	89	24
Z	90	25

위 표를 보면 c - 'A'의 결과가 알파벳의 순서(0~25)를 의미한다는 것을 쉽게 이해할 수 있다.

이 문제 특성상 공백은 공백으로 두고 대문자 혹은 소문자만 n만큼 이동한 문자로 이루어진 새로운 문자열을 만들어야 한다.

따라서 for 문 안 if 문을 통해 공백, 대문자, 소문자일 때를 구분해야 한다.

문제는 그냥 더하기만 하면 안 된다는 것이다.

문제를 읽어보면 "z"를 1만큼 밀면 "a"가 된다는 조건 때문이다.

즉, 알파벳 마지막 문자를 넘어가면 그 다음 ASCII 코드로 넘어가는 것이 아닌 대문자, 소문자 각각 그 루프 안에서 순환한다는 것을 유의해야 한다.

총 알파벳은 a~z, A~Z 각각 26개로 이루어져있다.

따라서 0번 알파벳부터 25번 알파벳이라고 생각하면 문제 접근하는 것이 좀 더 쉬워진다.

예를 들어 24번 알파벳을 3만큼 이동시키면 24 -> 25 -> 1 -> 2 가 되므로 b혹은 B가 된다.

이해를 돕기 위한 버전이다.

아래 코드는 문자를 n만큼 이동시킨 결과가 대문자의 마지막 문자('Z') 또는 소문자의 마지막 문자('z')를 넘어가는 경우 26을 빼 다시 처음으로 돌아오도록 구현한 것이다.

char c = s.charAt(i);

if (c == ' ') {
    sb.append(' ');
} else if ('A' <= c && c <= 'Z') {

    if (c + n > 'Z') {
        sb.append((char)(c + n - 26));
    } else {
        sb.append((char)(c + n));
    }

} else {

    if (c + n > 'z') {
        sb.append((char)(c + n - 26));
    } else {
        sb.append((char)(c + n));
    }

}

위의 코드를 굳이 26보다 클 때와 작을 때로 구분하지 않고 하나로 나타낼 수 있는 것은 '%' 연산자를 이용하는 것이다.

(char)('A' + (c - 'A' + n) % 26)
(char)('a' + (c - 'a' + n) % 26)

c - 'A'를 통해 문자를 0~25 범위의 숫자로 변환한 뒤 n만큼 이동시키고, % 26으로 다시 0~25 범위 안에서 순환하도록 만든 후 마지막으로 'A'를 더해 다시 문자로 변환하는 방식이다.

이렇게 하면 한 줄로 표현 가능하다.

이건 내가 정답으로 제출한 코드다.

class Solution {
    public String solution(String s, int n) {
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (c == ' ') {
                sb.append(' ');
            } else if ('A' <= c && c <= 'Z') {
                sb.append((char)('A' + (c - 'A' + n) % 26));
            } else {
                sb.append((char)('a' + (c - 'a' + n) % 26));
            }
        }

        return sb.toString();
    }
}

추가로 (char) 형변환 부분에 대해 첨언해보자면

char c = 'A';
sb.append(c + 1);

에 대한 결과는 66이다.

이유는 자바의 자동형변환 때문이다.

byte
↓
short
↓
char
↓
int
↓
long
↓
float
↓
double

Java에서는 연산 과정에서 위와 같은 순서로 자동 형변환이 일어난다.

char + int의 결과는 int이기 때문에 명시적으로 char 형태로 형변환을 해야 우리가 원하는 결과를 얻을 수 있다.

즉, 우리가 원하는 것은 66이아닌 B이므로 char 형태로 형변환을 해야한다.

이번 문제는 단순한 문자열 문제가 아니라 문자도 내부적으로는 숫자로 저장된다는 점과, Java의 자동 형변환 및 문자 연산을 이해하는 데 좋은 문제였다.

[프로그래머스] 이상한 문자 만들기

JK-LEE98 — Thu, 25 Jun 2026 21:27:14 +0900

이 문제는 대충 읽고 풀면 나처럼 틀릴 수 있다.

나는 처음 풀 때 문제를 대충 읽고 홀수 인덱스는 소문자 짝수 인덱스는 대문자로 하면 되는구나 하고 로직을 만들었다.

class Solution {
    public String solution(String s) {

        char[] arr = s.toCharArray();

        for (int i = 0; i < arr.length; i++) {
            if (i % 2 == 0) {
                arr[i] = Character.toUpperCase(arr[i]);
            } else {
                arr[i] = Character.toLowerCase(arr[i]);
            }
        }

        return new String(arr);
    }
}

위에 코드는 내가 처음 잘못 푼 코드다.

char 배열을 만들고 반복문을 통해 홀수 인덱스는 소문자로 짝수 인덱스는 대문자로 변경했고 마지막 char 배열을 문제의 요구사항에 맞게 String 형태로 return 했다.

이렇게 문제를 제출하니 꽤 많은 테스트 케이스를 실패했다.

그래서 내가 문제를 읽으면서 놓친 조건이 있나 다시 한 번 문제를 읽어봤다.

대충 읽고 넘어갔던 빈 공백에 대한 조건을 신경쓰지 않았던 것이다.

이 문제는 공백 다음에 나오는 문자열에 대해 다시 홀수, 짝수 인덱스를 고려해야하는 문제였던 것이다.

`.split(" ")` 을 사용하면 공백이 연속으로 붙어있을 때 문제가 생길 수 있다. 따라서 이 문제는 다르게 접근해야한다고 판단했다.

class Solution {
    public String solution(String s) {
        StringBuilder sb = new StringBuilder();
        int idx = 0;
        
        for (int i=0; i<s.length(); i++) {
            char c = s.charAt(i);    
            
            if (c == ' ') {
                sb.append(c);
                idx = 0;        
            } else {
                if (idx % 2 == 0) {
                    sb.append(Character.toUpperCase(c));
                } else {
                    sb.append(Character.toLowerCase(c));
                }
                
                idx++;
            }
        }
        
        return sb.toString();
    }
}

이건 최종 정답에 해당하는 로직이다.

sb와 idx라는 변수를 선언하고 반복문을 통해 공백일 경우 sb에 넣고 idx를 초기화 시킨다.

공백이 아닐 경우 idx는 초기화된 상태이기 때문에 짝수인덱스부터 시작하게 된다. (0도 짝수에 포함)

따라서 공백 이후 혹은 첫번째 문자열은 무조건 대문자가 되고 idx를 증가시킨다.

그 다음은 소문자 다시 대문자 .... 이렇게 흘러가게 된다.

결론적으로 우리가 원하는 알고리즘을 만들 수 있으며 최종 답을 반환할 수 있다.

북한산 향로봉 등산일기

JK-LEE98 — Tue, 23 Jun 2026 18:06:41 +0900

저번 사패산 등산 이후로 등산의 맛을 알게되어 아버지와 함께 북한산을 오르기로 했다.

아버지와 둘이 처음으로 하는 등산이라 설레이는 마음으로 출발했다.

진관사에서 시작하여 향로봉으로 올라가는 코스였는데 올라가다보니 길이 사라졌다.

뒤로 돌아와 아무리 찾아도 새로운 길도 안 보이고 사람도 보이지 않았다 ㅠㅠ

결국 정상까지 오르지 못 하고 하산했다.

내려와서 진관사에 있는 카페에 가서 시원한 커피와 팥빙수를 먹고 근처에 있는 고깃집에 가서 맛있는 소갈비도 먹었다.

다음에는 코스를 잘 알아보고 사람이 많은 곳으로 가야겠다 :)

[프로그래머스] 최대공약수와 최소공배수

JK-LEE98 — Tue, 23 Jun 2026 17:53:23 +0900

이 문제는 아주 쉬운 기초문제지만 최소공배수를 표현하는 법을 잊지 않기 위해 블로그에 남기기로 했다.

초기 내 코드

class Solution {
    public int[] solution(int n, int m) {
        int[] arr = new int[2];
        
        if (n % m == 0) {
            arr[0] = m;
            arr[1] = n;
        } else if (m % n == 0) {
            arr[0] = n;
            arr[1] = m;
        } else {
            for (int i=1; i<Math.max(n, m); i++) {
                if (m % i == 0 && n % i ==0) {
                    arr[0] = i;
                    int Num1 = m / i;
                    int Num2 = n / i;
                    arr[1] = i * Num1 * Num2;
                }
            }
        }

        return arr;
    }
}

최소 공배수를 구하는 코드를 보면 두 수를 최대 공약수로 나눈 값을 저장하는 Num1, Num2 변수 두 개를 생성하여

"최대 공약수 * Num1 * Num2" 와 같이 세 수를 곱하는 방식을 선택했다.

그러나 더 좋은 표현 방법이 있다는 것을 알게되었다.

arr[1] = n * m / arr[0];

다음과 같이 두 수의 곱을 최대공약수로 나누는 것이다.

초등 수학 레벨이지만 내가 작성했던 직관적인 방식 보다 코드도 짧고 변수를 새로 만들 필요도 없어서 유용해보인다.

[프로그래머스] 두 개 뽑아서 더하기

JK-LEE98 — Fri, 12 Jun 2026 22:43:03 +0900

나는 이 문제를 보고 예전 확률과 통계 같은 곳에서 풀던 문제들이 생각났다.

인덱스의 위치를 [0], [1] 이런식으로 표현해보겠다.

크기가 5인 배열이라고 가정해보면

[0] + [1], [0] + [2], [0] + [3], [0] + [4]

[1] + [2], [1] + [3], [1] + [4]

[2] + [3], [2] + [4]

[3] + [4]

이런식의 흐름을 떠올렸다.

이 생각을 기반으로 작성한 내 최종 코드다.

크기가 정해진 배열이 아니므로 ArrayList를 사용했고 앞서 설명한 방식으로 더하기 위해 이중 for문을 사용했다.

이후 문제 요구사항에 맞게 정렬을 했고 return 하기 위한 배열을 새로 만들어 list에 있는 값들을 넣음으로써 로직을 완성했다.

import java.util.*;

class Solution {
    public int[] solution(int[] numbers) {
        List<Integer> list = new ArrayList<>();
        
        for (int i=0; i<numbers.length-1; i++) {
            int sum = 0;
            
            for (int j=i+1; j<numbers.length; j++) {
                sum = numbers[i] + numbers[j];
                
                if (!list.contains(sum)) {
                    list.add(sum);
                }
            }
        }
        
        Collections.sort(list);
        
        int[] arr = new int[list.size()];
        
        for (int i=0; i<list.size(); i++) {
            arr[i] = list.get(i);       
        }
        
        return arr;
    }
}

나는 난이도와 상관없이 문제를 풀고 나서 찝찝한 느낌이 들면 언제나 gpt를 활용하여 최적화된 방법을 찾아본다.

이 과정에서 `HashSet`의 활용에 대해 알게 되었다.

아직 코딩테스트 경험이 적은 나에게는 생소한 것이었기에 기회 삼아 HashSet에 대한 것을 정리해보려고 한다.

HashSet이란?

중복을 허용하지 않는 집합(Set)

List

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

list.add(1);
list.add(1);
list.add(2);

결과:

[1, 1, 2]

중복이 허용된다.

HashSet

Set<Integer> set = new HashSet<>();

set.add(1);
set.add(1);
set.add(2);

결과:

[1, 2]

중복이 허용되지 않는다.

왜 HashSet이 빠른가?

if (!list.contains(sum)) {
    list.add(sum);
}

contains()는 앞에서부터 하나씩 검사한다.

예를 들어:

[3, 4, 5, 6, 7]

에서 7을 찾으려면

3 확인
4 확인
5 확인
6 확인
7 확인

최악의 경우 전부 검사한다.

반면 HashSet은

set.contains(7);

을 거의 즉시 찾는다.

내부적으로 해시(Hash) 를 사용하기 때문이다.

HashSet을 사용한 코드

import java.util.*;

class Solution {
    public int[] solution(int[] numbers) {

        Set<Integer> set = new HashSet<>();

        for (int i = 0; i < numbers.length - 1; i++) {
            for (int j = i + 1; j < numbers.length; j++) {
                set.add(numbers[i] + numbers[j]);
            }
        }

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

        Collections.sort(list);

        int[] answer = new int[list.size()];

        for (int i = 0; i < list.size(); i++) {
            answer[i] = list.get(i);
        }

        return answer;
    }
}

사패산 등산일기

JK-LEE98 — Wed, 10 Jun 2026 16:04:41 +0900

친구와 등산을 주기적으로 하기로 했다.

힘든 개발자 취업을 이겨내기 위해 등산은 아주 좋은 취미라고 생각했다.

더운 날씨에 객기를 부리면 안 되기 때문에 초보자 등산코스로 추천받은 사패산을 가기로 결정했다.

사패산은 둘레길 수준의 평지라고 알고 있었는데 친구가 갑자기 일반적인 코스가 아닌 원각사 코스로 갔다.

이 코스는 정확하진 않지만 일반 코스에 비해 시간을 짧게 걸리되 가파른 코스이다...ㅎ

왕복 한시간 반 정도라길래 이정도면 충분하지 싶었는데 페이스 조절에 실패했다.

사실 등산에 페이스 조절이 필요한지도 잘 몰랐다.

첫 번째 사진은 가다가 도저히 못 가겠다고 뻗어버린 나의 모습이다.

머릿 속에는 119를 부르고 싶을 정도로 숨막히고 힘들었지만 친구의 도움 덕에 정상까지 오를 수 있었다.

정상은 매우 아름다웠다.

내가 죽고 싶을 만큼 힘들었던 시간들을 전부 잊게 해주는 풍경이었다.

'고진감래' 라는 단어를 몸소 체험하고 느낄 수 있는 계기였다.

점진적으로 난이도를 높이며 등산의 맛을 느껴야겠다.