LeetCode 1768. Merge Strings Alternately 풀이 복기

문제 이해

이번에 푼 문제는 Merge Strings Alternately이다.

문제 자체는 어렵지 않았다.
두 문자열이 주어지고, 첫 번째 문자열의 문자부터 시작해서 두 문자열의 문자를 번갈아가며 합치면 된다.

예를 들어 다음과 같은 입력이 있다고 하자.

word1 = "abc";
word2 = "pqr";

결과는 다음과 같다.

a p b q c r

그래서 최종 결과는 다음과 같다.

"apbqcr"

만약 두 문자열의 길이가 다르면, 짧은 문자열이 끝난 뒤에 긴 문자열의 남은 문자를 그대로 붙이면 된다.

예를 들어 다음과 같은 입력이 있다.

word1 = "ab";
word2 = "pqrs";

이면 a, p, b, q까지 번갈아 붙이고, word2에 남은 r, s를 뒤에 붙이면 된다.

결과는 다음과 같다.

"apbqrs"

알고리즘 분류

이 문제는 문자열 처리 문제이다.

두 문자열을 같은 인덱스 기준으로 번갈아 확인하면서 새로운 문자열을 만들어야 한다.
따라서 배열이나 문자열을 순서대로 순회하는 기본적인 문제에 가깝다.

세부적으로는 두 문자열을 각각 가리키는 인덱스를 사용한다는 점에서 투 포인터의 기초 형태로도 볼 수 있다.

다만 복잡한 포인터 이동 조건이 있는 문제는 아니고, 단순히 같은 인덱스 i를 기준으로 word1, word2를 차례대로 확인하는 문제이다.

사용한 자료구조는 결과 문자열을 만들기 위한 StringBuilder이다.

문제 유형: 문자열 처리
세부 주제: 문자열 병합, 인덱스 순회, 투 포인터 기초
난이도: Easy
자료구조: String, StringBuilder

처음 풀이

처음에는 두 문자열 중 더 긴 길이를 구한 다음, 그 길이만큼 반복문을 돌렸다.

class Solution {
    public String mergeAlternately(String word1, String word2) {
        String answer = "";

        int a = word1.length();
        int b = word2.length();
        int c = a > b ? a : b;

        for (int i = 0; i < c; i++) {
            if (a > i) {
                answer += word1.charAt(i);
            }

            if (b > i) {
                answer += word2.charAt(i);
            }
        }

        return answer;
    }
}

처음 생각은 단순했다.

두 문자열을 같은 인덱스 기준으로 하나씩 확인하면서, 해당 위치에 문자가 있으면 결과 문자열에 붙이면 된다고 생각했다.

그래서 word1.length()와 word2.length()를 각각 구하고, 둘 중 더 긴 길이만큼 반복문을 돌렸다.

int a = word1.length();
int b = word2.length();
int c = a > b ? a : b;

그리고 반복문 안에서는 현재 인덱스 i가 각 문자열의 길이보다 작은지 확인했다.

if (a > i) {
    answer += word1.charAt(i);
}

if (b > i) {
    answer += word2.charAt(i);
}

이렇게 하면 한쪽 문자열이 먼저 끝나도 에러가 나지 않고, 남아 있는 문자열의 문자만 계속 붙일 수 있다.

예를 들어 word1 = "ab", word2 = "pqrs"라면 흐름은 이렇게 된다.

i = 0
word1[0] = a 추가
word2[0] = p 추가

i = 1
word1[1] = b 추가
word2[1] = q 추가

i = 2
word1은 더 이상 문자가 없음
word2[2] = r 추가

i = 3
word1은 더 이상 문자가 없음
word2[3] = s 추가

결과적으로 "apbqrs"가 만들어진다.

풀이 로직 자체는 맞았고, 제출도 가능했다.

다만 다른 풀이를 보면서 Java에서 문자열을 반복해서 더할 때는 String +=보다 StringBuilder를 사용하는 게 더 좋다는 것을 다시 정리하게 됐다.

String +=가 아쉬운 이유

내 처음 풀이에서는 결과 문자열을 만들 때 이렇게 작성했다.

String answer = "";

answer += word1.charAt(i);
answer += word2.charAt(i);

처음 볼 때는 그냥 answer에 문자를 하나씩 붙이는 것처럼 보인다.

하지만 Java의 String은 불변 객체라서, 한 번 만들어진 문자열의 내용은 바뀌지 않는다.

그래서 +=로 문자열을 붙인다고 해서 기존 문자열 뒤에 바로 문자가 붙는 게 아니다.
실제로는 새로운 문자열이 계속 만들어진다.

예를 들어 이런 코드가 있다고 하자.

String answer = "";

answer += "a";
answer += "p";
answer += "b";
answer += "q";

내가 생각하기에는 answer 하나에 계속 문자가 붙는 느낌이지만, 실제로는 이런 식으로 동작한다.

처음 answer = ""

answer += "a"
→ 새로운 문자열 "a" 생성

answer += "p"
→ 새로운 문자열 "ap" 생성

answer += "b"
→ 새로운 문자열 "apb" 생성

answer += "q"
→ 새로운 문자열 "apbq" 생성

즉, 중간에 "a", "ap", "apb" 같은 문자열들이 계속 만들어진다.

물론 더 이상 사용하지 않는 문자열은 나중에 GC가 정리하겠지만, 반복문 안에서 이런 식으로 계속 문자열을 만들면 불필요한 객체 생성이 많아질 수 있다.

이번 문제는 문자열 길이가 최대 100이라서 사실 String +=로 풀어도 큰 문제는 없다.

하지만 Java에서 반복문으로 문자열을 조립해야 하는 상황이라면 StringBuilder를 쓰는 게 더 좋은 습관이라고 느꼈다.

StringBuilder로 개선한 풀이

그래서 StringBuilder를 사용하면 다음과 같이 작성할 수 있다.

class Solution {
    public String mergeAlternately(String word1, String word2) {
        StringBuilder answer = new StringBuilder();

        int a = word1.length();
        int b = word2.length();
        int c = Math.max(a, b);

        for (int i = 0; i < c; i++) {
            if (i < a) {
                answer.append(word1.charAt(i));
            }

            if (i < b) {
                answer.append(word2.charAt(i));
            }
        }

        return answer.toString();
    }
}

기존 풀이와 전체 흐름은 거의 같다.

달라진 부분은 결과 문자열을 만드는 방식이다.

기존에는 String을 사용했다.

String answer = "";
answer += word1.charAt(i);

개선 풀이에서는 StringBuilder를 사용했다.

StringBuilder answer = new StringBuilder();
answer.append(word1.charAt(i));

StringBuilder는 String처럼 매번 새로운 문자열을 만드는 방식이 아니라, 내부에 문자를 계속 추가하는 방식이다.

그래서 반복문 안에서 문자열을 조립할 때 더 적합하다.

마지막에는 StringBuilder를 그대로 반환할 수 없기 때문에 toString()으로 문자열로 변환해서 반환한다.

return answer.toString();

그리고 두 문자열 중 더 긴 길이를 구하는 부분도 삼항 연산자 대신 Math.max()를 사용했다.

int c = Math.max(a, b);

기존 코드의 아래 코드와 같은 의미다.

int c = a > b ? a : b;

다만 Math.max()가 더 큰 값을 구한다는 의도가 더 잘 보이는 것 같다.

시간복잡도

이 문제는 결국 두 문자열의 문자를 한 번씩 확인한다.

문자열 word1의 길이를 n, word2의 길이를 m이라고 하면 시간복잡도는 다음과 같다.

O(n + m)

반복문은 두 문자열 중 더 긴 길이만큼 돌지만, 실제로 결과 문자열에 추가되는 문자의 총 개수는 n + m개이다.

결국 두 문자열의 모든 문자를 한 번씩 처리하므로 O(n + m)으로 볼 수 있다.

공간복잡도

결과 문자열을 저장하기 위해 StringBuilder를 사용한다.

최종 결과 문자열의 길이는 word1.length() + word2.length()이다.

따라서 공간복잡도는 다음과 같다.

O(n + m)

입력 문자열을 제외하고, 결과를 만들기 위한 추가 공간이 필요하기 때문이다.

정리

이번 문제는 알고리즘 자체보다는 Java에서 문자열을 다루는 방식에 대해 다시 생각해볼 수 있는 문제였다.

처음 풀이처럼 String +=를 사용해도 문제는 풀린다.
특히 입력 크기가 작으면 성능 차이가 크게 느껴지지 않을 수도 있다.

하지만 Java의 String은 불변 객체이기 때문에 반복문 안에서 +=를 사용하면 새로운 문자열 객체가 계속 생성될 수 있다.

그래서 반복적으로 문자열을 만들어야 하는 경우에는 StringBuilder를 사용하는 것이 더 적절하다.

이번 문제를 풀면서 기억할 점은 다음과 같다.

1. 문자열을 번갈아 합칠 때는 같은 인덱스를 기준으로 접근하면 된다.
2. 한쪽 문자열이 먼저 끝날 수 있으므로 인덱스 범위 체크가 필요하다.
3. Java의 String은 불변 객체다.
4. 반복문에서 문자열을 계속 붙일 때는 StringBuilder를 사용하는 것이 좋다.
5. StringBuilder로 만든 결과는 마지막에 toString()으로 변환해서 반환한다.

처음에는 단순히 문제를 맞히는 데 집중했는데, 풀이를 다시 보면서 String +=와 StringBuilder의 차이를 정리할 수 있었다.

앞으로 반복문 안에서 문자열을 조립해야 하는 문제가 나오면 StringBuilder를 먼저 떠올려야겠다.

static boolean isPrime(int num) {
    if (num < 2) return false;

    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) return false;
    }
    return true;
}

백준 2581번 풀다가 정리

1. 구글 클라우드 로그인

https://cloud.google.com/free?utm_source=google&utm_medium=cpc&utm_campaign=japac-KR-all-ko-dr-BKWS-all-core-trial-EXA-dr-1710102&utm_content=text-ad-none-none-DEV_c-CRE_668690472449-ADGP_Hybrid+%7C+BKWS+-+EXA+%7C+Txt+-GCP-General-core+brand-main-KWID_43700077514871055-kwd-6458750523&userloc_1009853-network_g&utm_term=KW_google+cloud&gad_source=1&gclid=Cj0KCQjw2ZfABhDBARIsAHFTxGx1L77xMGjYqC88XUk3PlxCYMPheRU28eD0s56u0E9txjBmV5vXrSoaAq02EALw_wcB&gclsrc=aw.ds

2. 새 프로젝트 만들기

프로젝트 이름 자유롭게 작성하시고 위치는 작성안해도 됩니다.

만들기 버튼 클릭

3. Google Sheets API 활성화

API 및 서비스 클릭

라이브러리 클릭

Google Sheets API 검색해서 사용 클릭

4. 서비스 계정 생성 및 키 발급

IAM 및 관리자 클릭

서비스계정 -> 서비스 계정 만들기 클릭

서비스 계정 이름 작성 후 완료 클릭

생성된 이메일 클릭

이 이메일 주소 저장해두기

키 -> 키 추가 -> 새키만들기 클릭

JSON 선택 후 만들기 클릭

만들기 클릭시 다운로드 된 JSON파일 저장해두기

5. Google Sheets 생성

공유버튼 클릭 해서 아까 저장해둔 이메일 주소를 편집자로 선택해서 공유하기

이 시트 정보와 저장한 JSON 키값으로 프로젝트와 구글스프레드시트 연동 진행함.

프로젝트 진행 중에 공공기관 API를 통해서 대용량으로 데이터를 받을 일이 생겼다. 안써본 JPA를 써보겠다고 무작정 JPA로 코드를 작성하였다. 데이터를 받는데 너무 오랜 시간이 걸려서 어떻게 하면 좀 더 빠르게 다운로드가 가능할지 고민해보았다. 여러가지로 조사해본 결과, 대용량 데이터 처리에는 MyBatis가 적합하다는 결론을 얻어 정리해보았다.

대용량 데이터 처리 시 JPA vs MyBatis 성능 비교

JPA와 MyBatis는 각각의 장점이 있지만, 대량 데이터를 처리할 때는 일반적으로 MyBatis가 더 빠릅니다.
그 이유와 상황별 최적의 선택을 정리해 보겠습니다.

1. JPA와 MyBatis의 차이점

특징 JPA (Hibernate) MyBatis

2. 대량 데이터 처리에서 MyBatis가 빠른 이유

- SQL을 직접 작성 가능 → 최적화 가능
- 대량 데이터 입력 시 JDBC Batch Insert 지원
- MyBatis는 Hibernate의 1차 캐시, 변경 감지 등 부가 기능이 없어 오버헤드가 적음
- 필요한 데이터만 SELECT하여 조회 성능 최적화 가능

JPA의 성능 저하 원인

1. Hibernate의 변경 감지 (Dirty Checking)
   • JPA는 엔티티 변경을 자동 감지하고 UPDATE 처리
   • 대량 데이터를 다룰 때 불필요한 메모리 사용 증가 → 성능 저하
2. 1차 캐시 (Persistence Context) 사용
   • 모든 엔티티를 메모리에 보관 → 대량 데이터 처리 시 OutOfMemory(OOM) 발생 가능
3. Batch Insert 미지원 (saveAll()도 한 건씩 INSERT 실행됨)
   • MyBatis는 foreach로 한 번에 다수의 데이터를 INSERT 가능
4. JPQL의 제한
   • 복잡한 SQL 최적화가 어려움 → JOIN 최적화 등 MyBatis보다 불리

3. 대량 데이터 처리 시 성능 최적화 방법

(1) JPA에서 Batch Insert 적용 (성능 개선)

@PersistenceContext
private EntityManager entityManager;

@Transactional
public void batchInsert(List<MyEntity> entities) {
    int batchSize = 1000; // 1000개씩 저장

    for (int i = 0; i < entities.size(); i++) {
        entityManager.persist(entities.get(i));

        if (i % batchSize == 0) {
            entityManager.flush();
            entityManager.clear();
        }
    }
}

개선 효과:

• flush()와 clear()를 사용하여 메모리 누수 방지
• 배치 크기(batchSize)를 조절하여 성능 최적화

(2) MyBatis를 활용한 Batch Insert

<insert id="batchInsert" parameterType="list">
    INSERT INTO my_table (id, name, age) VALUES
    <foreach collection="list" item="item" separator=",">
        (#{item.id}, #{item.name}, #{item.age})
    </foreach>
</insert>

void batchInsert(@Param("list") List<MyEntity> entities);

MyBatis에서는 foreach 문을 사용하여 한 번에 다수의 데이터를 INSERT 가능!

JDBC Batch 지원 → 성능 최적화
개별 SQL 실행보다 속도 빠름

(3) MyBatis에서 ON DUPLICATE KEY UPDATE 활용

<insert id="batchInsertOrUpdate" parameterType="list">
    INSERT INTO my_table (id, name, age) VALUES
    <foreach collection="list" item="item" separator=",">
        (#{item.id}, #{item.name}, #{item.age})
    </foreach>
    ON DUPLICATE KEY UPDATE 
    name = VALUES(name),
    age = VALUES(age)
</insert>

MySQL에서 중복된 키가 있으면 UPDATE, 없으면 INSERT
JPA의 merge()보다 훨씬 빠름

4. 실제 성능 비교

방식 10,000건 INSERT 100,000건 INSERT 1,000,000건 INSERT

대량 데이터 삽입 시 MyBatis가 JPA보다 2~5배 이상 빠름!

 결론: 언제 JPA vs MyBatis를 써야 할까?

사용 사례 JPA MyBatis

대량 데이터 처리라면 MyBatis를 추천!
JPA를 써야 한다면 Batch Insert 적용 필수!
트랜잭션 관리가 중요한 경우 JPA + Native Query 조합도 고려 가능

🔥 결론:

• 대량 데이터(INSERT, UPDATE, DELETE가 많음) → MyBatis 추천
• 비즈니스 로직 중심, 유지보수 중요 → JPA 사용 가능하지만 최적화 필수
• JPA를 유지하면서 성능을 높이려면 batchInsert() 적용

1. git 설치

2. docker 설치

3. jdk 21 설치

4. build gradle(./gradlew clean build)

5. docker build -t g2bplatform:1.0 .

6. msyql설치

7. db 생성

8.  docker run -d -p 8080:8080 g2bplatform:1.0

9. 외부접속 설정하기

작업했던 내용들을 조금씩 정리하려고 한다.

관리하는 사이트의 SSL인증서를 갱신하라는 메일을 받았다.

안내해준 사이트로 들어가서 로그인 후 갱신하면 된다.

1. 갱신하기 위해서는 우선 결제를 해야한다.

스타(*) 인증서로 1년에 무려 484,000 원

그래도 결제 진행해주고, 결제 몇시간 후에 인증서 파일을 메일로 보내주었다.

보통 cert, key 이렇게 두개 파일이 들어있고, 방화벽용 파일을 따로 보내주는 곳도 있었다.

그럼 이제 이 파일들로 무엇을 해야하는가

2. pem 파일 안의 코드들을 가동중인 웹서버 NGINX로 옮기기

nginx를 접속해주자. 보통 SSL파일은 최상위 폴더에서 

/etc/nginx/SSL 폴더 안에 존재한다.

기존 파일 백업을 잘해두자.(혹여나 그냥 바꿨는데 오류나면 낭패다.)

그리고 기존 파일명과 같게, 형식도 같게 해서 해당 폴더에 새 인증서 파일을 넣어준다.

3. NGINX의 conf.d(설정) 확인

vi 명령어를 통해 conf.d파일을 열어서 설정을 확인한다.

폴더의 위치나 파일명이 맞는지 확인하면 된다.

4. nginx 재기동

sudo nginx -t

명령어로 별 문제 없는지 테스트 한번 해주고

이런 결과 나오면 nginx를 재기동해주면 된다.

sudo service nginx restart

5. 호스팅업체를 이용중인 경우 SSL인증서 파일 전달 후 적용 요청

이렇게 한 후 SSL인증서가 잘 적용되었는지 확인하면 된다.

인증서 확인 방법은 다음과 같다.

브라우저에서 url왼쪽에 아이콘 클릭

뜨는 창에서 '이 연결은 안전합니다.' 클릭

뜨는 창에서 '인증서가 유효함' 클릭

그럼 이렇게 인증서 정보와 만료일이 나온다.

여기서 인증서 만료일이 옳게 바뀌었으면 잘 적용된 것이다!

풀이

10진법수 K를 N진법 수로 변환하는 방법은 K를 N으로 나눈 나머지를 역순서대로 배열하는 것이다.

코드

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        String[] temp = line.split(" ");
        int n = Integer.parseInt(temp[0]);
        int m = Integer.parseInt(temp[1]);
        String[] array = {
                "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
                "A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
                "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
                "U", "V", "W", "X", "Y", "Z"
        };

        String answer = "";

        while(n/m>0){
            n=n/m;
            answer += array[n%m];
        }
        answer += array[n%m];

        System.out.println(answer);

    }
}