딩코링코

사용자 취향 반영을 위한 음악 추천 알고리즘 개선 과정

bogyeom — Tue, 25 Mar 2025 02:09:18 +0900

사용자 맞춤형 음악 추천 기능을 구현하기 위해서는, 사용자의 취향을 정확하게 반영할 수 있는 알고리즘 설계가 핵심입니다.

MiTi 프로젝트에서는 이를 위해 곡의 특성을 기반으로 한 벡터 유사도 계산 방식을 도입하였고, 추천 정확도를 높이기 위한 리팩터링을 단계적으로 진행하였습니다.

기존 추천 알고리즘 설계 방식

설계한 알고리즘: 개인 맞춤형 음악 추천, 장르별 음악 추천, 유사 음악 추천

# user_records에 포함된 album_id에 대해 평균 특성 벡터를 계산하는 함수
def calculate_average_features(user_records, album_dict):
    feature_sums = np.zeros(len(next(iter(album_dict.values()))))  # 첫 번째 앨범의 특성 벡터 길이만큼 0으로 초기화
    count = 0

    for user_id, album_id in user_records:
        feature_sums += album_dict[album_id]
        count += 1

    if count == 0:
        return feature_sums
    else:
        return feature_sums / count  # 평균 특성 벡터 계산

# main 함수
def main():
    # MySQL 데이터베이스에 연결
    connection = pymysql.connect(
        host='mitidb.cvm64ss6y2xv.ap-northeast-2.rds.amazonaws.com',       
        user='minseo',  
        password='Alstj!!809', 
        database='mitiDB'
    )

    try:
        records, albums = fetch_records_and_albums(connection)

        # album_id를 키로 하고, 여러 특성을 값으로 하는 딕셔너리 생성
        album_dict = {album[0]: np.array(album[1:]) for album in albums}

        # user_record에 있는 모든 user_id에 대해 평균 특성 벡터 계산
        average_features = calculate_average_features(records, album_dict)

        similarities = []
        for album_id, features in album_dict.items():
            # 유클리드 거리 계산
            euclidean_distance = euclidean(average_features, features)
            similarities.append((album_id, euclidean_distance))

        # 유사도 기준으로 상위 20개의 앨범 선택
        top_20_albums = sorted(similarities, key=lambda x: x[1])[:20]

        # 결과를 customized_rec 테이블에 삽입
        with connection.cursor() as cursor:
            for user_id, _ in records:  # 모든 user_id에 대해 반복
                for album_id, distance in top_20_albums:
                    try:
                        cursor.execute(
                            "INSERT INTO customized_rec (user_id, album_id) VALUES (%s, %s)",
                            (user_id, album_id)
                        )
                    except pymysql.IntegrityError:
                        # 중복 키 에러가 발생하면 해당 항목을 삽입하지 않음
                        continue
            connection.commit()  # 변경사항을 커밋하여 데이터베이스에 반영

초기에는 Spotify에서 재생 가능한 곡의 오디오 특성(audio features)을 수집한 후,

사용자의 재생 기록에 포함된 곡들의 평균 특성 벡터를 계산하고,

이 벡터와 가장 유사한 곡들을 추천하는 방식으로 알고리즘을 설계했습니다.

예: danceability, energy, acousticness 등의 특성을 평균내어 사용자 취향을 표현하는 벡터를 구성

❗ 발생한 문제

기능 구현은 가능했지만, 실제 추천 결과를 보았을 때 사용자의 취향과 일치하지 않는 곡이 포함되는 문제가 발생했습니다.

그 원인을 분석해보니 다음과 같은 한계점이 있었습니다.

곡 수가 적은 재생목록은 평균값이 왜곡될 가능성이 높음
단순히 유클리드 거리로 유사도를 계산할 경우, 절대값 차이에 지나치게 민감하게 반응함

예를 들면, 운동 장르 플레이리스트에는 운동을 할 때 활력을 돋게 하기 위해 밝고 강한 음악을 추천하도록 설계하였지만, 차분하고 감미로운 음악이 추천되기도 하는 상황이 발생했습니다.

개선 방식

1. 유사도 계산 방식 변경 (유클리드 → 코사인 유사도)

여러 곡의 특성을 평균 낸 벡터는 스케일의 영향을 많이 받지 않기 때문에,

절댓값 차이를 계산하는 유클리드 거리보다는 벡터 간 방향을 비교하는 코사인 유사도가 더 적합하다고 판단했습니다.

실제로 유사도 계산에 있어 곡의 개수가 달라도 비슷한 경향성을 가진 벡터들끼리는 높은 유사도로 판단할 수 있어,

추천 정확도를 높이는 데 도움이 되었습니다.

2. 유사한 특성 값을 그룹으로 분류

< 음악 별 특성 값 정리 >

~~music_speechiness (곡의 말하기 부분의 비율): 가사가 없는 edm, 어두운 분위기의 랩 등 변수가 있는 요소이기 때문에 비교군에서 제외~~

값이 클수록 밝은 곡인 특성

music_danceability (곡의 춤출 수 있는 정도)

music_energy (곡의 에너지 수준)

music_loudness (곡의 음량 수준)

music_valence (곡의 긍정적/부정적 감정 정도)

music_tempo (곡의 템포)

값이 작을수록 밝은 곡인 특성

music_acousticness (곡의 어쿠스틱 특성) -> 주로 어쿠스틱 악기의 사용이 많은 음악이 차분한 경우가 많음

music_liveness (곡의 라이브 느낌 정도) -> 값이 클수록 청중의 소리나 라이브 환경의 특성이 포함되기 때문에 상대적으로 깔끔하지 않고 차분하다고 판단함

# 각 그룹의 특성 인덱스 정의 (0부터 시작)
    features_group1_indices = [1, 2, 4, 5, 6]  # danceability, energy, tempo, loudness, valence
    features_group2_indices = [0, 3]  # acousticness, liveness

    try:
        # user_record와 album 테이블에서 데이터 가져오기
        records, albums = fetch_records_and_albums(connection)
        # album_id를 정수로 변환하여 딕셔너리 생성
        album_dict = {album[0]: np.array(album[1:], dtype=float) for album in albums}  # 실수로 변환

        # user_id별로 추천 결과 계산
        user_ids = set(user_id for user_id, _ in records)
        user_recommendations = {}

        for user_id in user_ids:
            # 해당 user_id의 레코드만 필터링
            user_records = [(uid, aid) for uid, aid in records if uid == user_id]

            # 각 그룹에 대해 평균 특성 벡터 계산
            average_features_group1 = calculate_average_features(user_records, album_dict, features_group1_indices)
            average_features_group2 = calculate_average_features(user_records, album_dict, features_group2_indices)

            # 각 앨범 특성 벡터와 사용자 평균 특성 벡터 간 코사인 유사도 계산 후 리스트에 저장
            similarities_group1 = []
            similarities_group2 = []

            for album_id, features in album_dict.items():
                try:
                    feature_group1 = features[features_group1_indices]
                    feature_group2 = features[features_group2_indices]

                    if np.all(feature_group1 == 0) or np.all(average_features_group1 == 0):
                        similarity_group1 = 0
                    else:
                        similarity_group1 = 1 - cosine(average_features_group1, feature_group1)

                    if np.all(feature_group2 == 0) or np.all(average_features_group2 == 0):
                        similarity_group2 = 0
                    else:
                        similarity_group2 = 1 - cosine(average_features_group2, feature_group2)

                    similarities_group1.append((album_id, similarity_group1))
                    similarities_group2.append((album_id, similarity_group2))
                
                except Exception as e:
                    print(f"Error processing album_id {album_id}: {e}")

            # 각 그룹별로 유사도 내림차순으로 정렬
            sorted_group1 = sorted(similarities_group1, key=lambda x: x[1], reverse=True)
            sorted_group2 = sorted(similarities_group2, key=lambda x: x[1], reverse=True)

            # 중복된 앨범만 선택하여 상위 20개 앨범 리스트에 추가
            top_albums = []
            seen_album_ids = set()

            for album_id, similarity in sorted_group1 + sorted_group2:
                if album_id in seen_album_ids:
                    continue
                top_albums.append((album_id, similarity))
                seen_album_ids.add(album_id)
                if len(top_albums) == 20:
                    break
            
            user_recommendations[user_id] = top_albums

값이 클수록/ 작을수록 밝은 요소끼리 그룹으로 묶어 따로 유사도를 계산한 후,

유사도를 내림차순으로 정렬하고, 최대한 유사도가 강한 음악을 선별하기 위해 두 그룹에 모두 담겨있는 앨범만을 저장했습니다.

+ 추가로 중복 방지를 위한 코드를 삽입해 한 번 더 중복 저장을 예방하였습니다.

except pymysql.IntegrityError:
	continue

3. 장르별 음악의 적합성 향상

운동 (Workout)

높은 music_danceability: 춤추기 좋은 리듬
높은 music_energy: 활기찬 음악
높은 music_tempo: 빠른 템포
높은 music_loudness: 높은 볼륨, 강렬한 효과음

휴식 (Relaxation)

높은 music_acousticness: 차분하고 조용한 분위기
낮은 music_energy: 에너지 부족한 분위기
낮은 music_tempo: 느린 템포, 편안한 리듬

집중 (Focus)

낮은 music_loudness: 낮은 볼륨, 부드러운 사운드
낮은 music_tempo: 느린 템포, 차분한 리듬
높은 music_valence: 긍정적이고 희망적인 감정

파티 (Party)

높은 music_danceability: 춤추기 좋은 리듬
높은 music_energy: 활기찬 음악
높은 music_tempo: 빠른 템포
높은 music_valence: 긍정적이고 밝은 감정

스트레스 해소 (Stress Relief)

높은 music_acousticness: 자연스러운 소리, 어쿠스틱 악기 사용
높은 music_liveness: 라이브 느낌, 현장감 있는 사운드
낮은 music_tempo: 느린 템포, 차분한 리듬

여행 (Travel)

높은 music_energy: 에너지 넘치는 음악
높은 music_tempo: 빠른 템포, 활동적인 리듬
높은 music_valence: 긍정적이고 열정적인 감정

사랑 (Romance)

높은 music_acousticness: 어쿠스틱 악기와 조용한 분위기
높은 music_valence: 로맨틱하고 감정적인 음악
낮은 music_tempo: 느린 템포, 섬세한 리듬

수면 (Sleep)

높은 music_acousticness: 차분하고 조용한 분위기
낮은 music_energy: 에너지 부족한 분위기
낮은 music_tempo: 느린 템포, 부드러운 리듬

클래식 (Classical)

높은 music_acousticness: 어쿠스틱 악기와 조용한 분위기
낮은 music_tempo: 느린 템포, 고요한 리듬
높은 music_valence: 우아하고 감동적인 감정

우울 (Sadness)

낮은 music_valence: 부정적이고 슬픈 감정
낮은 music_energy: 에너지 부족한 분위기
낮은 music_tempo: 느린 템포, 침울한 리듬

대표적인 장르를 10개로 지정해 강조돼야 하는 특성을 3개씩 뽑아 동일한 방법으로 비슷한 특성끼리 그룹으로 묶어 계산을 진행했습니다.

결과

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

위에서 예를 들었던 운동장르의 코드 개선 전, 후를 비교해 보면 빠르고 밝고 활기찬 느낌에

훨씬 더 적합한 음악이 추천되는 것을 한눈에 확인할 수 있습니다.

✅ 마무리하며

평균 특성 벡터 기반의 추천 구조를 설계하면서 데이터를 해석하고, 적절한 기술을 선택하는 판단력의 중요성을 체감했습니다.

앞으로도 사용자의 경험을 중심에 두고, 끊임없이 개선하고 실험하며 더 나은 추천 시스템을 설계해 나가고 싶습니다.

전체 알고리즘 코드 보러 가기

spotify 크롤링 개선 과정 보러 가기

Spotify 음악 크롤링 중 마주한 문제들과 이를 해결한 과정

bogyeom — Fri, 21 Mar 2025 17:06:43 +0900

프로젝트 배경

음악 스트리밍 프로젝트 ‘MiTi’에서는 사용자의 취향에 맞는 음악을 추천하기 위해 Spotify API를 이용한 음악 데이터 크롤링이 필요했습니다. 크롤링 과정에서 다양한 문제들이 발생했고, 이를 해결하며 기능의 완성도를 높일 수 있었습니다.

spotify는 다른 플랫폼과는 달리 저작권이나 보안 문제를 책임지지 않아도 되고,

특히 맞춤형 추천 기능이 주 기능인 저희 웹서비스에서는 추천 알고리즘을 중요하게 생각했기 때문에, 음악의 특성(danceability, energy 등)을 자세히 가져올 수 있어 해당 api를 선택하기로 결정했습니다.

client_credentials_manager = SpotifyClientCredentials(client_id=client_id, client_secret=client_secret)

sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager)

csv_file_path = "spotify_tracks.csv"

chart_tracks = sp.playlist_tracks('37i9dQZEVXbMDoHDwVN2tF') #트랙 인기차트 id

with open(csv_file_path, 'w', newline='', encoding='utf-8') as file:
    writer = csv.writer(file)
    # 헤더
    writer.writerow([
        "id", "music_name", "music_id", "music_popularity", "album_image", "album_detail",
        "music_artist_name", "music_artist_id", "music_artist_popular", "music_genre", 
        "music_artist_genres", "music_artist_followers", "music_analysis_url", 
        "music_key", "music_duration_ms", "music_instrumentalness", "music_acousticness", 
        "music_danceability", "music_energy", "music_liveness", "music_loudness", 
        "music_mode", "music_speechiness", "music_tempo", "music_time_signature", 
        "music_valence", "music_track_href", "music_type", "music_uri"
    ])
    
    # 트랙마다 음악 정보 작성
    track_id = 1

    for track in chart_tracks['items']:
        track_info = track['track']
        album_id = track_info['album']['id']
        album_tracks = sp.album_tracks(album_id)['items']

        for album_track in album_tracks:
            # 개별 트랙의 상세 정보
            track_details = sp.track(album_track['id'])

            # 오디오 특징
            audio_features = sp.audio_features(album_track['id'])[0]
            
            # 아티스트 정보
            artist_names = []
            artist_ids = []
            artist_popularities = []
            artist_genres = []
            artist_followers = []

            for artist in album_track['artists']:
                artist_id = artist['id']
                artist_info = sp.artist(artist_id)
                artist_names.append(artist_info['name'])
                artist_ids.append(artist_info['id'])
                artist_popularities.append(artist_info['popularity'])
                artist_genres.append(', '.join(artist_info['genres']))
                artist_followers.append(artist_info['followers']['total'])

            # 행 작성
            writer.writerow([
                track_id, album_track['name'], album_track['id'], 
                track_details['popularity'],  # 개별 트랙의 인기도 가져오기
                track_info['album']['images'][0]['url'], track_info['album']['name'],
                ', '.join(artist_names), ', '.join(artist_ids), ', '.join(map(str, artist_popularities)),
                ', '.join(artist_names), ', '.join(artist_genres), ', '.join(map(str, artist_followers)),
                audio_features['analysis_url'], audio_features['key'], 
                audio_features['duration_ms'], audio_features['instrumentalness'],
                audio_features['acousticness'], audio_features['danceability'], 
                audio_features['energy'], audio_features['liveness'], 
                audio_features['loudness'], audio_features['mode'], 
                audio_features['speechiness'], audio_features['tempo'], 
                audio_features['time_signature'], audio_features['valence'], 
                audio_features['track_href'], audio_features['type'], album_track['uri']
            ])
            track_id += 1  # ID 값 증가

위 코드는 초기에 작성한 코드로, 인기차트의 id를 직접 삽입해 해당 차트에 담겨있는 음악들의 정보를 가져왔습니다.

가장 간단한 방법이기 때문에 오류 발생률이 적고, 빠르게 정보 수집이 가능하다는 장점이 있었지만, 여러 가지 문제점도 많이 발생했습니다.

❗ 크롤링 중 마주한 문제점과 해결 방법

1. 수동으로 음악 ID를 하나씩 검색해야 해 시간이 과도하게 소요됨

문제점 수동으로 ID를 가져오다 보니 크롤링 범위가 제한되고, 자동화가 어렵고 비효율적이었음
해결 방법 Spotify의 카테고리 정보를 활용해 자동으로 플레이리스트를 탐색하는 방식으로 전환
사용 코드

# Spotify에서 제공하는 카테고리 가져오기
categories = sp.categories(limit=50)  # 최대 50개의 카테고리 가져오기
for category in categories['categories']['items']:
	category_id = category['id']
    print(f"Fetching playlists from category: {category['name']}")

    # 카테고리별 플레이리스트 가져오기 (최대 20개)
    playlists = sp.category_playlists(category_id=category_id, limit=20)  # 각 카테고리당 20개의 플레이리스트
    for playlist in playlists['playlists']['items']:
    	playlist_id = playlist['id']
        playlist_name = playlist['name']
        print(f"Fetching tracks from playlist: {playlist_name}")

        # 플레이리스트에서 트랙 가져오기
        offset = 0
        limit = 50  # 트랙을 50개씩 가져오기
        total_tracks = sp.playlist_tracks(playlist_id, limit=1)['total']  # 전체 트랙 수 확인

2. 서로 다른 플레이리스트 간에 음악이 중복 저장됨

문제점 동일한 음악이 여러 플레이리스트에 포함되어 중복 데이터가 누적됨
해결 방법 음악 제목 기준으로 중복 여부를 검사한 후 저장
사용 코드

if music_name in recorded_music_names:
	continue

3. 특정 음악은 국내(KR)에서 재생이 불가능함

문제점 재생이 불가능한 음악까지 수집되어 실제 사용자 재생 시 오류 발생 우려
해결 방법 available_markets 필드에 KR이 포함되어 있는 음악만 수집
사용 코드

if track_info.get('is_playable', True) and 'KR' in track_info.get('available_markets', []):

4. 과도한 API 요청으로 Spotify API 호출 제한이 발생함

문제점 크롤링 범위가 넓어지며 일정 시간 후 API 호출 제한에 도달
해결 방법 카테고리 수, 플레이리스트 수, 트랙 수를 제한하고 요청 간 딜레이를 적용
사용 코드

time.sleep(REQUEST_DELAY)

✅ 마무리하며

이번 크롤링 작업을 통해 API 사용 시의 유의점과 효율적인 데이터 수집 방식에 대해 배울 수 있었습니다.

특히 단순히 데이터를 가져오는 것뿐 아니라, 서비스 환경에서 실제로 사용할 수 있는 데이터를 선별하고 처리하는 능력이 중요하다는 점을 실감했습니다.

전체 코드 보러 가기

크롤링한 데이터를 이용한 추천 알고리즘 설계 및 리팩터링 과정 보러 가기

[우테코 프리코스 BE] 3주차 회고록

bogyeom — Wed, 26 Feb 2025 16:53:34 +0900

이번 주차에는 예외 테스트 2개 중 1개를 실패해서 정말 아쉽게 마무리하게됐다. 이번 주 문제점을 파악하고 다음주엔 부족한 점을 모두 개선해보려고 한다 !

[https://github.com/woowacourse-precourse/java-lotto-7/pull/542](https://github.com/woowacourse-precourse/java-lotto-7/pull/542)

<hr>

## 3주차 [로또]

### 프로젝트 소개
이 프로젝트는 **로또**를 구현합니다.
사용자가 입력한 **당첨 번호**와 시스템이 생성한 **당첨 번호**를 비교하며 로또 게임을 진행합니다.

- 로또 번호는 1~45 사이의 중복하지 않는 7개의 무작위 값을 통해 당첨 여부를 결정합니다.
- 로또 구입 금액을 입력하면 구입 금액에 해당하는 만큼 로또를 발행해야 합니다.
- 당첨 내역 및 수익률을 출력하고 로또 게임을 종료합니다.
- 잘못된 입력이 들어올 경우 **`IllegalArgumentException`**이 발생하며 애플리케이션이 종료됩니다.

 

### 기능 요구 사항
1. **로또 번호**
 - 발행 횟수만큼 1~45 사이의 중복하지 않는 6개의 무작위 값을 뽑아 출력합니다.

2. **번호 비교**
 - 구매한 로또 번호와 당첨 번호를 비교하여 당첨 개수를 기록합니다.

3. **당첨 결과**
 - 당첨 내역 및 수익률을 출력합니다.

4. **예외 처리**
 - 입력 값이 유효하지 않을 경우 **`IllegalArgumentException`**을 발생시키고 애플리케이션을 종료합니다.

 

### 입출력 요구 사항
**입력**
1. 로또 구입 금액(1,000원 단위)
2. 당첨 번호(,로 구분된 6개의 중복되지 않는 1-45사이의 정수)
3. 보너스 번호(당첨 번호와 중복되지 않는 1-45 사이의 정수)

**출력**
- 구매한 개수 만큼의 6개의 로또 번호
- 당첨 통계(내역 및 수익률)

 

### 3주차 미션 진행시 개선할 점
이번 구현에서 코드 리뷰와 공통 피드백을 통해 개선해야겠다고 느낀 부분:

- 계층형 아키텍처에 대해 학습
- 단위테스트하기
- 도메인에서 뷰를 직접적으로 참조하지 않도록 하기
- 매직넘버는 상수로 빼기

 

### 미션을 끝마친 후 소감
이번 미션이 가장 아쉬움이 많이 남았다..! 예외 테스트를 실패하기도 했지만, 매주 새롭게 코드를 발전시키면서 작성하고 있기 때문에 내가 지금 하고 있는게 잘 하는건가..? 이걸 여기에 작성하는게 맞나? 하는 의심을 계속 품으면서 코드를 작성했던 기억이 난다.
개선할 점이라고 작성헀던 부분들 중, 지키지 못해 아쉬웠던건 뷰를 컨트롤러에서 서비스랑 연결시켰어야 했는데, 서비스에서 뷰와 연결시켜서 너무 많은 책임을 두게 했던 것 같아서 그게 아쉽다!
그리고 매직 넘버를 상수로 빼보려고 했는데, 일관성이 없게 몇 개만 상수로 뺀게 적절하지는 않았던 것 같다. 다른 분들의 코드를 보니 정해진 값은 대부분 모두 상수로 빼서, 반성하게 됐고 상수 값들을 한 클래스에 정리해서 분리하는 것도 좋을 것 같다!

 

### 코드 리뷰를 하며 고쳐야겠다고 생각했던 점
- 예외 메시지나 정해진 값 모아서 정의해두기 (enum 활용해보기)
- 참조 자료형을 그대로 리턴하기보단, 복사한 리스트를 반환하는 방식을 사용하기 (방어적복사)
- 클래스의 내용에 맞게 이름 짓기& 클래스에서는 유사한 기능만 실행하도록 !
- 메서드에서 파라미터 값 변경하지 않기(불변 취급), 의미없는 코드 작성하지 않기
- 예외 처리 후 다시 입력받도록 구현하기

 

이번 4주차는 마지막인만큼 고쳐야겠다고 생각한 점들을 꼭 다 지켜보고싶다 !

[우테코 프리코스 BE] 2주차 회고록

bogyeom — Wed, 26 Feb 2025 16:53:00 +0900

3주차 과제를 진행하기 전 회고록을 급하게 작성하려고 한다 ! 반성할 점은 뭔지, 더 개선해야할 점은 뭔지 정리를 하면 훨씬 코드를 짜는 데에 도움이 될 것 같다.

[https://github.com/woowacourse-precourse/java-racingcar-7/pull/982](https://github.com/woowacourse-precourse/java-racingcar-7/pull/982)
<hr>

## 2주차 [문자열 덧셈 계산기]

### 프로젝트 소개
이 프로젝트는 **자동차 경주 게임**을 구현합니다.
사용자가 입력한 **경주할 자동차 이름**으로 주어진 **횟수만큼 이동**하며 경기를 진행합니다.

- 각 자동차는 0~9 사이의 무작위 값을 통해 전진 여부를 결정합니다.
- **4 이상**의 값이 나왔을 때 해당 자동차가 전진합니다.
- **여러 대의 자동차**가 동일한 거리에 도달할 수 있으며, 이 경우 공동 우승자가 됩니다.
- 잘못된 입력이 들어올 경우 **`IllegalArgumentException`**이 발생하며 애플리케이션이 종료됩니다.

 

### 기능 요구 사항
1. **자동차 이름**
 - 쉼표(`,`)로 구분된 문자열로 입력합니다.
 - 각 이름은 **최대 5자**까지만 허용됩니다.

2. **이동**
 - 사용자가 입력한 횟수만큼 경기를 반복합니다.
 - 각 시도마다 **자동차별로 0~9 사이**의 무작위 값을 생성합니다.
 - **4 이상**일 경우 자동차가 전진합니다.

3. **우승자 결정**
 - 가장 멀리 전진한 자동차가 우승자가 됩니다.
 - 우승자가 여러 명일 경우, **쉼표(,)로 구분**하여 표시합니다.

4. **예외 처리**
 - 입력 값이 유효하지 않을 경우 **`IllegalArgumentException`**을 발생시키고 애플리케이션을 종료합니다.

 

### 입출력 요구 사항
**입력**
1. 쉼표로 구분된 경주할 자동차 이름 목록
2. 시도할 횟수 (정수)

**출력**
- 매 시도마다 자동차별 전진 결과를 출력합니다.
- 경기 종료 후 최종 우승자를 출력합니다.

 

> 이번엔 저번주에 반성해야할 점에 대해 작성한 것을 지키려고 최대한 노력해보았다. 추가로 더 학습해야할 부분도 많겠지만 너무 욕심내지 않고, 한 단계씩 확실하게 공부하는 것이 목표기 때문에 전에 작성한 반성해야할 점을 위주로 지키려고 했다.

 

### 2주차 목표
- 예외 상황에 대해 더 깊이 고민해볼 것
- 메서드 이름을 어떤 동작을 하는지 알 수 있도록 정확히 작성할 것
- 책임을 분리하도록 더 자사히 메소드를 분리할 것
- if문이 많이 중첩되지 않도록 할 것
- 테스트 코드 작성해볼 것
- 배열 대신 컬렉션 사용해볼 것

 

### 배운 점 & 깨달은 점(+코드 리뷰)

2주차 목표를 지키기 위해서 하나하나 체크해가며 코드를 작성하였다. 다른 것은 최대한 지키려고 노력했지만 졸업 작품도 같이 준비하다보니, 테스트 코드까지 작성하기엔 시간이 좀 부족했다..! 통합적인 큰 테스트만 작성했는데, **이번 주엔 단위 테스트까지 작성하는게 목표**이다. 테스트 코드를 짤 때, 어려움을 겪느라 더 오래걸렸다. 큰 단위의 테스트는 단순히 결과값이 일치하는지 테스트 코드만 짜면 되지만 랜덤 값을 추출하는 경우엔 어떻게 그 값을 테스트하지..?라는 의문이 들면서 그 부분에 대해서는 테스트를 진행하지 못했다. 다른 분들의 코드를 보니 코드를 짤 때부터 테스트를 하기 위한 코드들을 작성하셨다. 이런 부분은 학습 후에 다음주 회고록을 작성할 때 배운 내용을 적어봐야겠다!
그리고 계층형 아키텍처에 대해 알아보면 어떠냐는 리뷰도 받았다. 사실 저번주에 작성한대로 기본적인 domain(model)-view-controller로만 작성하느라 각 클래스에 너무 많은 역할을 하게 만들었던 것 같다. 또한 **도메인 계층에서 뷰 계층을 직접 참조하는 것은 좋지 않다**는 것도 처음 알았다. 정말 배워도 배워도 배울게 계속 나오고 모르는 것도 정말 많은 것 같다. 그리고 그만큼 코드 리뷰를 하는 것이 정말 중요하다는 것도 깨달았다.

 

### 다음주 목표
- 계층형 아키텍처에 대해 학습
- 단위테스트(1주 차 피드백 강의 참고)
- 도메인에서 뷰를 직접적으로 참조하지 않도록 하기
- 매직넘버는 상수로 빼기

[우테코 프리코스 BE] 1주차 회고록

bogyeom — Wed, 26 Feb 2025 16:51:25 +0900

늦었지만 1주차부터 프리코스 과정을 되돌아보고자 한다 !
https://github.com/woowacourse-precourse/java-calculator-7/pull/1323

1주차 [문자열 덧셈 계산기]

프로젝트 소개

이 프로젝트는 문자열 덧셈 계산기를 구현합니다.
사용자가 입력한 문자열에서 숫자를 추출해 합을 계산하며, 쉼표(,)와 콜론(:)을 기본 구분자로 사용합니다.
또한, 커스텀 구분자를 정의할 수 있으며, 잘못된 입력이 들어오면 예외를 발생시킵니다.

기능 요구 사항

기본 구분자: 쉼표(,)와 콜론(:)을 기준으로 문자열을 분리합니다.
- 예: "1,2,3" → 결과: 6
커스텀 구분자: "//[구분자]\n" 형식으로 입력하면 커스텀 구분자로 분리합니다.
- 예: "//;\n1;2;3" → 결과: 6
빈 문자열: 입력이 빈 문자열이면 0을 반환합니다.
- 예: "" → 결과: 0
예외 처리:
- 숫자가 아닌 값이나 음수가 입력되면 IllegalArgumentException을 발생시키고 프로그램이 종료됩니다.
- 예: "1,-2,3" → 예외 발생

입출력 요구 사항

입력: 구분자와 양수로 이루어진 문자열
출력: 입력된 숫자들의 합

springboot 프로젝트를 진행한 경험도 있고, 공부도 했지만 mvc패턴에 대해서 정확히 이해를 못하고 있었던 것 같다. 그래서 1주차는 mvc패턴에 대해 학습하고, 기본적인 패턴만 지키면서 구현해보는 것을 목표로 두고 진행하였다 !

1주차 목표

mvc 패턴에 대해 익숙해지기
기능별로 메서드, 클래스 자세히 나눠보기
readme에 기능을 자세히 작성해두기
다양한 예외 상황 생각해보기

배운 점 & 깨달은 점

아예 손도 못대고 있었던 상황이라 최대한 기본적인 구조만 익힌 후, 그 패턴에 맞게 구현해보는 것을 목표로 하고 직접 써서 정리해보며 파일을 구성했다.

이렇게 직접 손으로 써가면서 이해하고 구현하니까 어느정도 MVC패턴에 대해 익히게 되었고, 단일 책임 원칙을 지켜보려 노력했다.

테스트 코드까지는 작성하지 못했는데, 다른 분들의 코드를 보며 테스트 코드의 중요성을 느꼈다. 기본적인 테스트는 통과했지만, 테스트 코드를 예외 상황에 따라 정말 세세하게 여러 상황을 생각하여 작성한 분들이 많았다.

반성해야할 점 (+코드 리뷰)

예외 상황에 대해 더 깊이 고민해볼 것
메서드 이름을 어떤 동작을 하는지 알 수 있도록 정확히 작성할 것
책임을 분리하도록 더 자사히 메소드를 분리할 것
if문이 많이 중첩되지 않도록 할 것
테스트 코드 작성해볼 것
배열 대신 컬렉션 사용해볼 것

물론 아직도 공부해아할 것이 많고, 부족한 것이 많지만 시간이 없는 틈에 지원한 것이기 때문에 매주 조금씩이라도 성장한 점이 있다면 만족할 것 같다 !
매주 하나라도 더 배워 나가는 것이 앞으로의 목표이다 !

[programmers] 같은 숫자는 싫어

bogyeom — Fri, 20 Sep 2024 21:09:55 +0900

문제 풀이: 연속돼서 중복인 숫자가 들어가지 않도록 배열을 다시 저장함

import java.util.Stack;

public class Solution {
    public int[] solution(int []arr) {
        Stack<Integer> stack = new Stack<>();
        
        for (int i : arr) {
            if (!stack.isEmpty() && stack.peek() == i) {
                continue;
            } else {
                stack.push(i);
            }
        }
        
        int[] answer = new int[stack.size()];
        
        for (int i = stack.size() - 1; i >= 0; i--) {
            answer[i] = stack.pop();
        }

        return answer;
    }
}

배열, ArrayList, Stack 세 개의 방법 모두 가능하지만, 스택 문제라 스택으로 풀이 해 보았음

[programmers] 의상

bogyeom — Fri, 20 Sep 2024 20:37:41 +0900

문제 풀이 : 의상의 이름은 중요하지 않고, 의상의 종류별로 몇 가지의 의상이 있는지 확인한 후 조합하는 경우의 수를 구해야 함

각 옷마다 의상의 수+1이 종류 별 경우의 수인데, 예를 들어 위 표에서 얼굴은 안경을 쓰는 경우, 선글라스를 쓰는 경우, 아무것도 쓰지 않는 경우 이렇게 2+1개의 종류이므로 총 경우의 수는 3x2x2x2임

이때! 모든 하나도 안 입는 경우가 발생하므로 1을 빼주어 3x2x2x2-1이 됨

import java.util.HashMap;

class Solution {
    public int solution(String[][] clothes) {
        int answer = 1;
        
        HashMap<String, Integer> map = new HashMap<>();
        
        for(String[] c: clothes) {
            String category = c[1];
            map.put(category, map.getOrDefault(category, 0)+1);
        }
        
        for(int i: map.values()) {
            answer *= (i+1);
        }
        
        return answer-1;
    }
}

<몰랐던 부분>

map.put(category, map.getOrDefault(category, 0)+1);에서 getOrDefault는 키가 카테고리인 것의 값이 없으면 기본 값을 0으로 갖고 1을 더한다는 뜻임

즉 처음에는 처음 저장되는 값이므로 기본값 0에 +1을 하여 해당 카테고리의 값이 1로 저장되고, 그 다음엔 1+1인 2로 저장됨

이런 방식으로 해당 카테고리의 의상이 몇 개인지 알 수 있게 됨

[programmers] 전화번호 목록

bogyeom — Fri, 13 Sep 2024 21:51:39 +0900

문제 풀이 : 배열과 해시로 모두 풀이할 수 있음 !

첫번째 번호가 다음 번호의 접두사인지 확인해야하는 문제

import java.util.Arrays;

class Solution {
    public boolean solution(String[] phone_book) {
        boolean answer = true;
        
        Arrays.sort(phone_book);
        
        for(int i=0; i<phone_book.length-1; i++) {
            if(phone_book[i+1].startsWith(phone_book[i])) {
                answer = false;
            }
        }        
        return answer;
    }
}

처음엔 배열로 풀이해보았는데, 먼저 배열을 정렬한 뒤 startsWith를 사용해 접두사인지 확인하여 문제를 해결함

import java.util.HashSet;

class Solution {
    public boolean solution(String[] phone_book) {
        
        boolean answer = true;
        
        HashSet<String> set = new HashSet<>();
        
        for(String phone: phone_book) {
            set.add(phone);
        }
        
        for(String phone: phone_book) {
            for (int i = 1; i < phone.length(); i++) {
                if(set.contains(phone.substring(0,i))) {
                    return false;
                }
            }
        }
        
        return answer;
    }
}

값 하나를 비교하는거라 HashMap보다는 HashSet이 더 적합할 것이라고 생각해서 HashSet을 사용했음

해시 문제라 이게 더 간단할 것이라고 생각해서 해시를 이용하여 다시 풀어본 건데, 오히려 더 복잡하고 길고 시간이 오래 걸리는 것 같아 좋은 방법은 아닌 것 같음

[programmers] 완주하지 못한 선수

bogyeom — Wed, 11 Sep 2024 16:27:31 +0900

문제 풀이 : 마라톤에 참여한 선수 중 완주하지 못한 선수의 이름을 출력해야 함

hash는 키 값이 중복되지 않게 저장되는데 마라톤 선수의 이름이 중복될 수 있다고 해서

방법이 생각이 나지 않아 chatgpt에게 방법을 물어봤음 ( 다음에 다시 혼자 풀어볼 것 ! )

key값에 참가자 이름, value값에 사람 수를 작성하라고 알려줌

import java.util.HashMap;

class Solution {
    public String solution(String[] participant, String[] completion) {

        String result = "";

        HashMap<String, Integer> map = new HashMap<>();

        for(String name : participant) {
            if(map.containsKey(name)) {
                int count = map.get(name);
                map.put(name, count+1);
            } else {
                map.put(name, 1);
            }
        }

        for(String name : completion) { 
            if(map.get(name)==1) {
                map.remove(name);
            } else {
                int count = map.get(name);
                map.put(name, count-1);
            }
        }

        for (String name : map.keySet()) {
            if (map.get(name) > 0) {
                result = name;
            }
        }

        return result;
    }
}

내가 작성한 코드

마지막에 출력 부분도 어떻게 string 형태로 출력하는지 몰라 오래 걸렸는데

이건 hashmap을 잘 몰라서 그런 것 같아서 개념 공부의 필요성을 느낌

[programmers] 폰켓몬

bogyeom — Wed, 11 Sep 2024 15:41:51 +0900

문제 풀이 : 해당 문제는 중복되지 않는 수가 몇 개인지 찾아 출력하는 문제인데, 이때 출력 값은 N/2보다 클 수 없는 조건을 갖고 있음

처음에는 해시 타입을 사용해 본 적이 없어서 막무가내로 배열을 만들어 하나하나 비교해보았음

시간 복잡도가 너무 올라가고, 정확도가 떨어져 해시맵을 사용해 봄

import java.util.HashMap;

class Solution {
    public int solution(int[] nums) {
        int answer = 0;
        int a = nums.length;
         HashMap<Integer, Integer> map = new HashMap<>();
        for(int i=0; i<a; i++) {
            map.putIfAbsent(nums[i], i);
        }

        if(map.size() >= a/2) {
            answer = a/2;
        } else{
            answer = map.size();
        }

        return answer;
    }
}

물론 이 방법도 정답이지만 더 간단하게 할 방법이 있을 것 같아 다른 분들의 풀이 방법과 ChatGPT를 사용해 HashSet이 더 적합하다는 걸 알았음

단순히 숫자만 비교하는 문제이기 때문에, 중복된 숫자는 삽입되지 않는 HashSet을 사용하는 것으로 수정

import java.util.HashSet;

class Solution {
    public int solution(int[] nums) {
        int answer = 0;
        
        HashSet<Integer> set = new HashSet<>();
        
        for(int i : nums) {
            set.add(i);
        }
        
        answer = Math.min(set.size(), nums.length/2);
        
        return answer;
    }
}

코드 수정 후 훨씬 빠르고 간결해졌음

Java Streams API를 사용하여 풀이하신 분도 있었는데, 다음에는 스트림에 대해 공부해서 이를 이용해 다시 풀이해보고 싶음