4-giljihun #23

giljihun · 2025-05-11T16:14:37Z

🔗 문제 링크

킹

✔️ 소요된 시간

1h

✨ 수도 코드

구현 + 시뮬 문제는 아직 폴더가 없길래 정석적인 문제 찾아서 하나 풀어봤습니다!

접근

~~8x8 체스판 만들기~~ -> 실제 구현중에 버려졌씁니다.
이동 컨트롤러 정의 (dx, dy)
이동 로직 정의
돌을 밀치는 로직 정의

핵심 구현 대상

본 문제의 핵심은 구현중에서도
"알파벳 -> 좌표" 변환 을 잘 구현하는 문제인거같습니다.

왜냐면,

실제 코테에서 아스키/스칼라 변환 이 잘 기억이 안날거같아서 그렇게 느꼈고.
생각보다 보드 게임/아스키변환 문제가 생각보다 자주 보이는 것 같습니다.

실제 함수분리도 아래처럼 컨버터 구현만 했는데요!

// MARK: - Functions
// asciiValue: 문자 → 숫자 (ex. ‘A’ → 65)
// UnicodeScalar: 숫자 → 문자 (ex. 65 → ‘A’)

func toRealCoordinate(_ pos: String) -> (Int, Int) {
    let x = Int(pos.first!.asciiValue! - 65)
    let y = 8 - Int(String(pos.last!))!
    return (x, y)
}

func toChessCoordinate(from position: (Int, Int)) -> String {
    let x = String(UnicodeScalar(position.0 + 65)!)
    let y = String(8 - position.1)
    return x + y
}

asciiValue 는 문자 → 숫자로 변환할 때 사용합니다.
예: 'A'.asciiValue! == 65 → 'A' → 0으로 만들고 싶으면 - 65

UnicodeScalar 는 숫자 → 문자로 변환할 때 사용합니다.
예: UnicodeScalar(65)! == "A" → 0 → 'A'로 만들고 싶으면 + 65

이 두개는 익혀두면 분명 효용이 있어보입니다!

Int() 초기화는 항상 옵셔널(Int?)을 뱉는다.

// let movingCnt = Int(N.components(separatedBy: " ")[2])
guard let movingCnt = Int(N.components(separatedBy: " ")[2]) else { exit(0) }

본 코드를 보면 기존에 위처럼 작성했다가 guard let으로 감싼 부분이 있어요.
이유가 왤까요?

// 이동 로직
for _ in 0..<movingCnt {

이유는 movingCnt를 활용하는 for문에 있습니다.
guard let으로 옵셔널을 언래핑 해주지 않으면, movingCnt에는 옵셔널 Int가 들어가기 때문에 for문의 조건으로 넣을 수가 없지요.

Int()는 변환 실패 가능성 때문에 항상 Int? 타입의 값을 반환합니다.

후기

다른 구현은 일반적인 구현이라 따로 적진 않겠습니다.
코드보고 궁금한거 여쭤봐주세요 !! ~

sep037 · 2025-05-15T10:47:20Z

무가 쉽다고 했는데 난 어려웠다
문자열 쪼개고 나눠서 처리하는 부분 구글링 많이 했어요 = 이런 거 안 써본 것 같음 = 나의 결함
그래도 학습이 잇엇따. 보람차다.

심지어 문제 잘못 읽고 좌표로 생각해서 저 directionMap 반대로 넣고 안돼서 절망함

그치만 해냄
1시간 걸린 길 대단하다

//
//  main.swift
//  1063
//
//  Created by Seungeun Park on 5/15/25.
//

import Foundation

// 위치 문자열을 숫자 좌표로 바꾸는 함수
func chessToTuple(pos: String) -> (Int, Int) {
    let col = Int(pos.first!.asciiValue! - Character("A").asciiValue!) // 알파벳 대신 숫자로 접근하고 싶었음
    let row = Int(String(pos.last!))! - 1                              // 1 ~ 8을 0 ~ 7로 바꿈
    return (row, col) // 왜냐면 이차원 배열 쓸 거니까
}

// 숫자 좌표를 체스 문자열로 바꾸는 함수 -> 이건 정답 출력을 위함
func tupleToChess(_ row: Int, _ col: Int) -> String {
    let colChar = String(UnicodeScalar(col + Int(Character("A").asciiValue!))!)
    let rowStr = String(row + 1)
    return colChar + rowStr
}

let location = readLine()!.split(separator: " ")
let kingLocation = String(location[0])
let stoneLocation = String(location[1])
let N = Int(location[2])!

// 위치를 숫자 튜플로 변환
var king = chessToTuple(pos: kingLocation)     // (row, col)
var stone = chessToTuple(pos: stoneLocation)   // (row, col)

let directionMap: [String: (Int, Int)] = [ // 딕셔너리밖에 생각이 안 났어요. 혹시 딕셔너리로 안 푼 사람 ? (아직 길 코드 안 봄)
    "R": (0, 1),
    "L": (0, -1),
    "B": (-1, 0),
    "T": (1, 0),
    "RT": (1, 1),
    "LT": (1, -1),
    "RB": (-1, 1),
    "LB": (-1, -1)
]

for _ in 0..<N {
    let command = readLine()!
    let (dy, dx) = directionMap[command]! 

    let newKing = (king.0 + dy, king.1 + dx)

    if (0..<8).contains(newKing.0) && (0..<8).contains(newKing.1) { // 이 문법은 구글링함 ! -> 이것도 피드백 받고 싶어요 ..
        if newKing == stone { // 왕이랑 돌이랑 위치가 같으면
            // 돌도 같은 방향으로 이동
            let newStone = (stone.0 + dy, stone.1 + dx)
            // 돌도 이동 가능한지 확인
            if (0..<8).contains(newStone.0) && (0..<8).contains(newStone.1) {
                king = newKing
                stone = newStone
            }
            // 돌이 벗어나면 킹도 못 감
        } else {
            // 돌이 없으니 킹만 이동 -> 킹이라고 하니까 킹받는데 킹 맞긴 함
            king = newKing
        }
    }
}

print(tupleToChess(king.0, king.1))
print(tupleToChess(stone.0, stone.1))

sep037 · 2025-05-15T10:48:11Z

giljihun/구현/[BOJ] 킹.swift

오 이건 나랑 같군

sep037 · 2025-05-15T10:48:42Z

giljihun/구현/[BOJ] 킹.swift

오 이것도 나랑 같다

저는 enum으로 해줬어요 !

enum Command: String { case R, L, B, T, LB, RB, LT, RT func getDirection() -> (row: Int, col: Int) { switch self { case .R: return (0, 1) case .L: return (0, -1) case .B: return (-1, 0) case .T: return (1, 0) case .LB: return (-1, -1) case .RB: return (-1, 1) case .LT: return (1, -1) case .RT: return (1, 1) } } }

의도적으로 케이스가 나뉘는 것에 대해서는 enum을 좀 써봤습니다. 사용할때는 command.getDirection()하면서 해당 커맨드에 대한 이동할 좌표값을 가져왔어요 !
길선생님코드보니까 dictionary로 하면 참조 두번 안거쳐도 되고 훨씬 깔끔한 것 같네요!
아마 여기서 enum방식이 빛을 보려면 여기(enum)안에서 다른 메서드를 만들던지.. 좀 더 많은 것을 했어야 했던 것 같습니닷

오호 저도 딕셔너리 사용했는데 enum으로 하면 휴먼 에러 방지 등에 좋겠네요!

sep037 · 2025-05-15T10:49:18Z

giljihun/구현/[BOJ] 킹.swift

헉 이것도 나랑 똑같다 ㅋㅋ

글로니 코드랑 거의 똑같네요! 0..<8 범위가 자주 나오는데 이런 값은 상수로 빼줘도 좋을 듯 합니다!

let chessMapRange: Range<Int> = 0..<8

매직넘버 조심해야겠어요!

MuchanKim · 2025-05-16T11:58:22Z

@sep037 제가 쉽다고 한 이유는 이미 풀어봤던 문제였기 때문에 그런 거였어요.............. ^^ 그리고 길 문제치곤 쉬웠다?

MuchanKim

쿠쿠 풀어봤던 문제들이 등장하기 시작했군요.
전에 함수형 프로그래밍 방식에 적응해보자고 이 문제를 학습하면서 풀었었던 기억이납니다..
문제를 처음부터 풀진 않고 예전 문제를 보고 다듬는 정도로만 했습니다..!

다들 좌표를 아스키로 변환하셨군요? 수학적 접근.. 전 아직 어려워요 직관적으로 풀래요. 직관적인게 좋은거가타요~~(잔소리 가능)

import Foundation

let moveFunctions: [String: (Int) -> Int] = [
    "R": { $0 + 1 },    
    "L": { $0 - 1 },    
    "T": { $0 + 8 },    
    "B": { $0 - 8 },    
    "RT": { $0 + 9 },   
    "LT": { $0 + 7 },   
    "RB": { $0 - 7 },   
    "LB": { $0 - 9 }    
]

// 킹과 돌이 같은 위치에 있는지 확인하는 함수
func checkSamePosition(king: Int, stone: Int) -> Bool {
    return king == stone
}

// 주어진 위치에서 해당 방향으로 이동 가능한지 확인하는 함수
func moveableCheck(position: Int, command: String) -> Bool {
    switch command {
    case "R": return (position + 1) % 8 == 0 ? false : true 
    case "L": return (position == 0 || position % 8 == 0) ? false : true  
    case "T": return 56...63 ~= position ? false : true  
    case "B": return 0...7 ~= position ? false : true  
    case "RT": return (position + 1) % 8 == 0 || 56...62 ~= position ? false : true  
    case "LT": return (position == 0 || position % 8 == 0) || 56...62 ~= position ? false : true  
    case "RB": return 0...7 ~= position || (position + 1) % 8 == 0 ? false : true  
    case "LB": return 0...7 ~= position || (position == 0 || position % 8 == 0) ? false : true  
    default: return false
    }
}

// 킹과 돌의 이동을 처리하는 함수
// 이동이 불가능한 경우 nil을 반환
func processMove(king: Int, stone: Int, command: String) -> (king: Int, stone: Int)? {
    // 이동 함수가 존재하고, 킹이 이동 가능한지 확인
    guard let moveFunction = moveFunctions[command],
          moveableCheck(position: king, command: command) else {
        return nil
    }
    
    // 킹의 새로운 위치 계산
    let newKing = moveFunction(king)
    
    // 킹이 돌과 같은 위치로 이동하는 경우
    if checkSamePosition(king: newKing, stone: stone) {
        // 돌도 같은 방향으로 이동 가능한지 확인
        guard moveableCheck(position: stone, command: command) else {
            return nil
        }
        // 킹과 돌 모두 이동
        return (newKing, moveFunction(stone))
    }
    
    // 킹만 이동
    return (newKing, stone)
}

// 체스판의 모든 위치를 문자열로 표현한 배열
let chessMap: [String] = ["A1", "B1", "C1", "D1", "E1", "F1", "G1", "H1",
                          "A2", "B2", "C2", "D2", "E2", "F2", "G2", "H2",
                          "A3", "B3", "C3", "D3", "E3", "F3", "G3", "H3",
                          "A4", "B4", "C4", "D4", "E4", "F4", "G4", "H4",
                          "A5", "B5", "C5", "D5", "E5", "F5", "G5", "H5",
                          "A6", "B6", "C6", "D6", "E6", "F6", "G6", "H6",
                          "A7", "B7", "C7", "D7", "E7", "F7", "G7", "H7",
                          "A8", "B8", "C8", "D8", "E8", "F8", "G8", "H8"]


// Input
let input: [String] = readLine()!.components(separatedBy: " ").map { $0 }

var kingPosition: Int = chessMap.firstIndex(of: input[0])!
var stonePosition: Int = chessMap.firstIndex(of: input[1])!
let cycle: Int = Int(input[2])!

for _ in 0..<cycle {
    let command: String = readLine()!
    
    // 이동이 가능한 경우에만 위치 업데이트
    if let newPositions = processMove(king: kingPosition, stone: stonePosition, command: command) {
        kingPosition = newPositions.king
        stonePosition = newPositions.stone
    }
}

// 최종 위치 출력
print(chessMap[kingPosition])
print(chessMap[stonePosition])

MuchanKim · 2025-05-16T12:22:45Z

giljihun/구현/[BOJ] 킹.swift

문자열 쪼갤 때 split대신 components를 쓰신 이유가 있을까요? split이 substring을 반환하기 때문에 String 씌우는 것 보다 components가 낫다고 생각하셨나요?? 이게 효율이 좋나요?? 혹은 가독성?? (물음표살인마)

불필요한 String 변환이 많다면, split이 나을 수도 있지만
components가 복사 비용이 있기에 일부 차이가 있지만,
제가 알기로 성능 차이가 거의 없고 본 문제에선 가독성 측면에서 components가 간결하고 좋다고 판단했습니다!

MuchanKim · 2025-05-17T03:06:20Z

giljihun/구현/[BOJ] 킹.swift

글로니 코드랑 거의 똑같네요! 0..<8 범위가 자주 나오는데 이런 값은 상수로 빼줘도 좋을 듯 합니다!

let chessMapRange: Range<Int> = 0..<8

MuchanKim · 2025-05-17T03:08:08Z

giljihun/구현/[BOJ] 킹.swift

좌표 변환을 아스키로 하셨군요.. 다른 풀이나 블로그 글도 좀 봤는데 대부분이 이렇게 풀이하신 듯! 좋은 접근입니다~!

bishoe01 · 2025-05-17T08:51:38Z

giljihun/구현/[BOJ] 킹.swift

이런경우에는 항상

0 < nextPosOfKing.0 < 8

이런식으로 해줄 생각만했는데, contains하니까 훨씬 깔끔한것같아요. 참 swift스러운걸 잘 쓰시는군요 다음에 잘 써먹겠습니닷

오호 맞네요 contains를 잘 사용해서 보기 좋네요!

저도 처음써봤는데. 제 기억으로 (0..<cnt).forEach 이런 구문을 쓰려고하면서
비슷한 간결성을 가진 .contains를 차용했습니다! ㅋㅋ

bishoe01

import Foundation

typealias Position = (row: Int, col: Int)

enum Command: String {
    case R, L, B, T, LB, RB, LT, RT

    func getDirection() -> (row: Int, col: Int) {
        switch self {
        case .R: return (0, 1)
        case .L: return (0, -1)
        case .B: return (-1, 0)
        case .T: return (1, 0)
        case .LB: return (-1, -1)
        case .RB: return (-1, 1)
        case .LT: return (1, -1)
        case .RT: return (1, 1)
        }
    }
}


// var Board = Array(repeating: Array(repeating: 0, count: 8), count: 8)

func isRange(_ pos: Position) -> Bool {
    return pos.row >= 0 && pos.row <= 7 && pos.col >= 0 && pos.col <= 7
}

// 이미 변환한 친구를 다시 아스키로 돌려오는 작업
func translate(_ pos: Position) -> String {
    return String(UnicodeScalar(pos.col + 65)!) + String(pos.row + 1)
}

func solution(king locationKing: String, stone locationStone: String, _ n: Int, _ commands: [String]) {
    let king = Array(locationKing)
    let stone = Array(locationStone)
    var kingPos: Position = (row: Int(String(king[1]))! - 1, col: Int(king[0].asciiValue! - 65))
    var stonePos: Position = (row: Int(String(stone[1]))! - 1, col: Int(stone[0].asciiValue! - 65))

    // 시작에 첨부한 사진 로직 그대로 흐름 가져갔어요 ! 
    // 로직 시작
    for command in commands {
        let command = Command(rawValue: command)!.getDirection()
        let newKingPos: Position = (row: kingPos.row + command.row, col: kingPos.col + command.col)
        // 갈 수 있나 없나 ?
        if !isRange(newKingPos) {
//            print("range")
            continue
        }
        else {
            // 공백에 킹 옮기기
            if newKingPos != stonePos {
                kingPos = newKingPos
            }
            else {
                let newStonePos = (row: stonePos.row + command.row, col: stonePos.col + command.col)
                // 돌이 못간대 !
                if !isRange(newStonePos) {
                    continue
                }
                // 돌도 이동할 수 있으니 둘다 옮기기
                else {
                    kingPos = newKingPos
                    stonePos = newStonePos
                }
            }
        }
    }
    print(translate(kingPos))
    print(translate(stonePos))
}

저는 처음에 행(A ~ H) 열(1 ~ 8) 이니까 이걸 원래 보드(2차원배열)에서 건드려주려고
행을 숫자로 변환시켜서 2차원배열에서 용이하게 이동해주려고 시작을 했는데, 막상 완성하고보니 굳이 2차원배열이 필요없겠다 싶어서 빼줬습니다.
고려할거는

0~7에서 벗어나냐?
이동할 공간에 돌이 있냐?
이동할 공간에 돌이 있으면 돌도 이동할 수 있냐?
이거 3개라고 생각해서 나온 사진의 흐름대로 조건문의 흐름을 따라가신다면 이해가 쉬울 수 있습니다!
그렇게하고 마지막에 이제 다시 결과값인 kingPos와 stonePos를 translate함수를 통해 아스키로 변환해서 출력해줬어요.

// 아래는 원래 시도하려고 했었던 chessPosition 구조체 코드 입니다.
// 여기안에서 isRange 함수도 쓰고, translate 함수도 쓰고 하려했는데, 너무 익숙하지 않은 방향이라서 어떻게 활용할지 잘 모르겠더라구요..! 그래서 중도하차하셨습니다.

struct ChessPosition {
    var row: Int
    var col: Int

    init(_ position: String) {
        let chars = Array(position)
        self.row = Int(String(chars[1]))! - 1
        self.col = Int(chars[0].asciiValue! - Character("A").asciiValue!)
    }
}

alstjr7437

다른 분들 리뷰를 다 잘달아주셔서 좋네요!!

처음에 헉 체스게임 구현인가 하고 겁먹었다가 다행이 이동이라 편하게 풀었습니다!!
코드는 다른분들이랑 거의 비슷한 것 같아요!

alstjr7437 · 2025-05-17T11:48:19Z

giljihun/구현/[BOJ] 킹.swift

오호 저도 딕셔너리 사용했는데 enum으로 하면 휴먼 에러 방지 등에 좋겠네요!

alstjr7437 · 2025-05-17T11:48:48Z

giljihun/구현/[BOJ] 킹.swift

오호 맞네요 contains를 잘 사용해서 보기 좋네요!

YooGyeongMo

저는 0 Based indexing으로 풀어서 -1, +1 을 해주어야했고

체스보드를 만들지 않고 자체적으로 체크해주면된다 생각해서 따로 체스판에 추적하지않았습니닷 !

YooGyeongMo · 2025-05-18T10:27:45Z

giljihun/구현/[BOJ] 킹.swift

입력 디테일 ... He knows the way !!! 캬..

YooGyeongMo · 2025-05-18T10:28:17Z

giljihun/구현/[BOJ] 킹.swift

오 8*8 행렬을 만드셨군요 ! 이번에 저는 안 만들고 자체적으로 벗어나는지 안 벗어나는지만 확인했었어요 !

YooGyeongMo · 2025-05-18T10:29:25Z

giljihun/구현/[BOJ] 킹.swift

이 부분은 저와 너무 똑같이 풀었는데요 ?

import Foundation // 가장 아래가 1 가장 위가 8 행은 -가 위로가는것. let direction: [String: (Int, Int)] = [ "R": (1,0), "L": (-1,0), "B": (0,-1), "T": (0,1), "RT": (1,1), "LT": (-1,1), "RB": (1,-1), "LB": (-1,-1) ] // .first/.last는 항상 Optional(Element?) 타입 , .asciiValue, unicodeScalar는 값이 없을수도 있어서 Optional로 반환 func transformToNum(_ chess: String) -> (Int, Int) { let colValue = Int(chess.first!.asciiValue! - Character("A").asciiValue!) let rowValue = Int(String(chess.last!))! - 1// Int()는 String, Double, Float, NSNumber등은 됨 Char는 X return (colValue, rowValue) } func transformToChess(_ target: (Int,Int)) -> String { let colChar = String(UnicodeScalar(target.0 + Int(Character("A").asciiValue!))!) let rowChar = String(target.1 + 1) return colChar + rowChar } let targetInfo = readLine()!.split(separator: " ").map{ String($0) } var kingInfo = transformToNum(targetInfo[0]) var stoneInfo = transformToNum(targetInfo[1]) let testCase = Int(targetInfo[2])! func solution() { for _ in 0..<testCase { let moveInfo = readLine()! guard let move = direction[moveInfo] else { continue } let nKing = (kingInfo.0 + move.0 , kingInfo.1 + move.1) // 체스판 벗어나면 무시 0 Based Indexing if nKing.0 < 0 || nKing.0 >= 8 || nKing.1 < 0 || nKing.1 >= 8 { continue } //킹이 이동할 자리에 돌이 있으면ㅠ if nKing == stoneInfo { let nStone = (stoneInfo.0 + move.0, stoneInfo.1 + move.1) if nStone.0 < 0 || nStone.0 >= 8 || nStone.1 < 0 || nStone.1 >= 8 { continue } //돌 이동 가능하면 ㄱㄱ kingInfo = nKing stoneInfo = nStone } else { //그냥 킹만 kingInfo = nKing } } print(transformToChess(kingInfo)) print(transformToChess(stoneInfo)) }

contains와 if or문 and문 비교가 뭐가 더 빠른지 궁금하네요 !

찾아보니.. contains사용으로는 내부적으로 함수 호출도 있고해서 약간 느릴 수 있지만 미비해보입니다.
데미갓처럼 직접 조건을 비교하는 방식은 연산으로만 처리를 하니 더 빠를 것 같습니다!

추가적으로 contains 사용은 보다. 본 문제에선 직관적이고 간결한 측면에서 좋아보이네요!
물론 조건문으로 나열하면~ 예외처리나 이런 부분에서 더욱 강점이 있어보여요!

2025-05-12 킹

8023e4e

giljihun self-assigned this May 11, 2025

giljihun added 작성 중 ⏱️ giljihun 😘 리뷰 기다리는 중 🔥 and removed 작성 중 ⏱️ labels May 11, 2025

github-actions bot requested review from MuchanKim, YooGyeongMo, alstjr7437, bishoe01 and sep037 May 12, 2025 09:54

sep037 approved these changes May 15, 2025

View reviewed changes

MuchanKim approved these changes May 17, 2025

View reviewed changes

bishoe01 reviewed May 17, 2025

View reviewed changes

bishoe01 approved these changes May 17, 2025

View reviewed changes

alstjr7437 approved these changes May 17, 2025

View reviewed changes

YooGyeongMo approved these changes May 18, 2025

View reviewed changes

YooGyeongMo added 리뷰 완료 ✔️ and removed 리뷰 기다리는 중 🔥 labels May 18, 2025

giljihun merged commit ed2bbc8 into main May 19, 2025
9 checks passed

alstjr7437 deleted the 4-giljihun branch May 23, 2025 06:13

4-giljihun #23

4-giljihun #23

Uh oh!

Conversation

giljihun commented May 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

🔗 문제 링크

✔️ 소요된 시간

✨ 수도 코드

접근

핵심 구현 대상

Int() 초기화는 항상 옵셔널(Int?)을 뱉는다.

후기

Uh oh!

sep037 commented May 15, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

MuchanKim May 17, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

MuchanKim commented May 16, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

MuchanKim left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

giljihun May 18, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

MuchanKim May 17, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

bishoe01 left a comment

Choose a reason for hiding this comment

Uh oh!

alstjr7437 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

YooGyeongMo left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

giljihun commented May 11, 2025 •

edited

Loading

sep037 commented May 15, 2025 •

edited

Loading

MuchanKim May 17, 2025 •

edited

Loading

MuchanKim commented May 16, 2025 •

edited

Loading

MuchanKim left a comment •

edited

Loading

giljihun May 18, 2025 •

edited

Loading

MuchanKim May 17, 2025 •

edited

Loading