3-YooGyoengMo

[YooGyeongMo]

🔗 문제 링크

색종이

✔️ 소요된 시간

20분

✨ 수도 코드

사실 문자열 문제, 혹은 딕셔너리, 해시 문제를 풀려했으나, 해당 문제를 넣은 이유는 이번 삼성 코테 때 색종이 붙이기에 관해서 다양한 요구사항들을 정확하게 구현할 수 있느냐 에 대한 문제였습니다.

코테 문제를 풀 때 꽤나 조건이 까다로웠던거 같아, 해당 문제를 보면서 좀 더 최적화 시킬만한 방법이 없나해서 문제를 찾아보았습니다.

이번 문제는 간단하게 직사각형도 아니고 10X10 정사각형이 왼쪽아래 좌표에서 부터 추가되어서 겹치는 부분을 제외하고 넓이를 구하면 되는 문제입니다.

저는 항상 이런 문제를 풀 때, 시작 인덱싱과 끝 인덱싱에 대해서 고민을 많이 하는편입니다.

문제 조건

1. 100 * 100 정사각형 종이에 정사각형 색종이를 추가하는 것이기에 10,000 번 체크하면 브루트 포스로 풀 수 있을 거 같은 생각이 듦.
2. 브루트포스로 돌 때 그나마 조금이라도 탐색을 최적화하기 위해서 시작 인덱스와 끝 인덱스를 고민해봄
3. 그 결과, 행과 열에서 10칸만 더 가고 해당 좌표 = 1 이런식으로 업데이트 시켜주면 될듯 함.
4. 이후 다 돌면서 1인 부분을 result에 누적 count해주면 되겠다 생각이 듦.

📚 새롭게 알게된 내용

DFS/BFS로 풀었을 시에 해당 문제가 좀 더 성능면에서 뛰어날까 ?

아직 저의 머리로는 잘 모르겠습니다. 결국 DFS/BFS로 해도 visited를 체크해주어야하고 Bool 체크면에서 공간 측면이 더 효율적일거같긴하네요.

더 좋은 코드가 있다면 알려주시면 감사하겠습니다.

이후에는 슬라이딩 윈도우와 같은 문제들을 한 번 파보도록 하겠습니다.

아래 코드는 제가 알아보다 보니 Bool을 활용한 flatMap.filter 함수를 이용해서 푼 답안지입니다.

var paper = [[Bool]](repeating: [Bool](repeating: false, count: 101), count: 101)

let n = Int(readLine()!)!
for _ in 0..<n {
    let input = readLine()!.split(separator: " ").map { Int($0)! }
    let x = input[0], y = input[1]
    for y in y..<y + 10 {
        for x in x..<x + 10 {
            paper[y][x] = true
        }
    }
}

print(paper.flatMap { $0 }.filter { $0 }.count)

[bishoe01]

저는 처음에 cnt * 100으로 종이 안겹쳤을때의 최대값을 answer로 둔다음에, 이제 paper[i][j] += 1 로 해서 1이상으로 되어있는 부분은 오히려 빼주는 방식으로 했는데, 2개 이상 겹쳤을때를 고려하지 않았었나봐요..! 그래서 저도 결국 0에서 + 해주게 , 데미안 선생님과 동일하게 풀었습니다 !

[YooGyeongMo]

색종이 함수 직이네예

[bishoe01]

import Foundation

func 색종이(_ cnt: Int, _ papers: [(x: Int, y: Int)]) {
    var answer = 0
    var grid = Array(repeating: Array(repeating: false, count: 100), count: 100)

    for (x, y) in papers {
        for i in x..<x+10 {
            for j in y..<y+10 {
                grid[i][j] = true
            }
        }
    }

    for i in 0..<100 {
        for j in 0..<100 {
            if grid[i][j] {
                answer += 1
            }
        }
    }
    print(answer)
}

위에서 말씀드렸듯 동일한 풀이인 것 같습니다! 이번 사이클 고생하셨어요!

[MuchanKim]

(짤 뭐냐고요 ㅋㅋㅋㅋ)

우선 이 문제는 제가 푼지 얼마 안된 문제였기에 풀이가 얼추 기억났었습니다!
데미안 코드에서 0,1 -> false, true 차이밖에 없는 것 같아요!
개선할 점이 있다면 올려주신 다른분 코드처럼 flatMap + filter해주는게 더 좋아보입니다. (아래에 성능 테스트 결과 있습니다.)

데미안 입력 부분 가져다 썼습니다!

for _ in 0..<T {
    let input = readLine()!.split(separator: " ").map { Int($0)! }
    let (x, y) = (input[0], input[1])
    
    for i in x..<x+10 {
        for j in y..<y+10 {
            paper[i][j] = true
        }
    }
}

for i in 0..<maxSize {
    for j in 0..<maxSize {
        if paper[i][j] { res+=1 }
    }
}

for 루프 vs flatMap+filter vs joined+filter

gpt한테 물어보니, flatMap + filter를 쓰는게 for문보다는 느릴 거라고 하더라고요. 그래서
100x100 사이즈에 30%정도만 true를 심고 찾아내는 테스트 코드를 작성해달라고 했습니다.

결과는 ??

flatMap이 제일 빨랐습니다(역시 GPT는 교차검증이 필요합니다). 여러번 시도해도 비슷한 차이를 보였어요.
flatMap(압도적) > for 루프(2차) > joined

For 루프: 2956 (시간: 2129.326105117798 ms)
flatMap + filter: 2956 (시간: 657.9310894012451 ms)
joined + filter: 2956 (시간: 2221.289038658142 ms)

"저수준의 코드가 더 빠르다"라는게 기존의 제 생각이었는데 꼭 그렇지만은 않네요..!

한 줄 요약: 중첩 for문의 경우 [i][j]와 같이 이중 인덱싱 비용이 드는 반면, flatMap은 1차원 배열로 변환하기 때문에 간접 참조 비용을 줄여준다.
그리고 flatMap이 최적화가 잘되어있다네요.

테스트 용 코드

import Foundation

// 테스트용 2차원 배열 생성 (100x100)
var paper = Array(repeating: Array(repeating: false, count: 100), count: 100)

// 랜덤하게 일부 값을 true로 설정 (약 30%)
for i in 0..<100 {
    for j in 0..<100 {
        if arc4random_uniform(100) < 30 {
            paper[i][j] = true
        }
    }
}

// 성능 측정 함수
func measureTime(_ title: String, _ operation: () -> Int) {
    let startTime = CFAbsoluteTimeGetCurrent()
    let result = operation()
    let timeElapsed = CFAbsoluteTimeGetCurrent() - startTime
    print("\(title): \(result) (시간: \(timeElapsed * 1000) ms)")
}

// 각 방법으로 테스트 실행 (여러 번 반복하여 평균적인 성능 측정)
let iterations = 1000

// 방법 1: for 루프 
measureTime("For 루프") {
    var count = 0
    for _ in 0..<iterations {
        count = 0
        for i in 0..<100 {
            for j in 0..<100 {
                if paper[i][j] {
                    count += 1
                }
            }
        }
    }
    return count
}

// 방법 2: flatMap + filter
measureTime("flatMap + filter") {
    var count = 0
    for _ in 0..<iterations {
        count = paper.flatMap { $0 }.filter { $0 }.count
    }
    return count
}

// 방법 3: joined + filter (Swift 5.2+)
measureTime("joined + filter") {
    var count = 0
    for _ in 0..<iterations {
        count = Array(paper.joined()).filter { $0 }.count
    }
    return count
}

// 결과 확인을 위한 한 번의 계산
var forLoopResult = 0
for i in 0..<100 {
    for j in 0..<100 {
        if paper[i][j] {
            forLoopResult += 1
        }
    }
}

let flatMapResult = paper.flatMap { $0 }.filter { $0 }.count
let joinedResult = Array(paper.joined()).filter { $0 }.count

// 세 가지 방법의 결과가 일치하는지 확인
print("\n결과 일치 여부: \(forLoopResult == flatMapResult && flatMapResult == joinedResult)")
print("true 값 개수: \(forLoopResult)")

[sep037]

처음 접근은 수학 문제풀듯이 전체 사각형 다 구해서 겹쳐지는 부분의 영역을 빼줄까 하다가
인덱싱 작업하면서 저조차도 헷갈릴 것 같아서 ㅋㅋㅋㅋ 살짝 서치(?) 해봤습니다.
어차피 최종적으로 검은색 부분만 고려해서 넓이를 구하면 되는 거라서 그냥 방문 느낌으로다가 .. 접근해보려고 했어요

처음에 100 x 100 2차원 배열을 만들어주고 주어지는 좌표값 x,y 쪽으로 +10 해준 부분을 1로 바꿔주는 방식 !
그리고 최종적으로 1의 개수를 카운트하는 식으로 했어용
시간 초과될 줄 알았는데 바로 통과돼서 머쓱 . .

( 제가 지금 글을 쓰는 시점은 다른 분들의 리뷰를 보지 않은 상태라서 방법이 겹칠 수 있습니다 ! ! ㅎ )

//
//  main.swift
//  2563
//
//  Created by Seungeun Park on 5/6/25.
//

import Foundation

let N = Int(readLine()!)!
var board = Array(repeating: Array(repeating: 0, count: 100), count: 100) // 100 x 100 배열 만들기
var result = 0


for _ in 0 ..< N {
    let location = readLine()!.split(separator: " ").map { Int($0)! }
    var X = location[0]
    var Y = location[1]
    
    for i in X..<X+10 {
        for j in Y..<Y+10 {
            board[i][j] = 1
        }
    }
}ㅁ

for i in 0..<100 {
    for j in 0..<100 {
        if board[i][j] == 1 {
            result += 1
        }
    }
}

print(result)

재밌는 문제 .ᐟ.

[alstjr7437]

다들 마지막에 반복문을 한번 더돌려서 result값을 뽑아내셨군요!!

저는 result는 if문을 통해서 바로 계산되도록 진행했습니다!
이미 갔던 곳(true)면 결과값은 더해주지 않도록!

var peper = Array(repeating: Array(repeating: false, count: 100), count: 100)
var result = 0

for _ in 0..<Int(readLine()!)! {
    let point = readLine()!.split(separator: " ").map { Int(String($0))! }
    
    for x in point[0]..<point[0] + 10 {
        for y in point[1]..<point[1] + 10 {
            if x <= 100 && y <= 100 && peper[y][x] != true{
                peper[y][x] = true
                result += 1
            }
        }
    }
}

print(result)

[giljihun]

결과 계산을 마지막에 하냐~ 빼곤 똑같은 로직으로 풀었네요!
확실히 풀었던 문제는 기억에 잘 남긴하네요. 하하..

전 이 문제 되게 괜찮다고 생각이 듭니다.
색칠 여부를 단순히 2차원 배열로 관리하는 로직 자체가 직관적이면서도,
문제의 의도(겹치는 영역은 한 번만 계산)를 정확히 반영하는 구조니까요.

또한 색종이 겹침이라는 현실적인 비유 덕분에
조건을 코드로 옮기는 과정에서 “공간을 채운다”는 개념이 명확하게 그려지는 점도 학습 효과가 좋다고 느꼈습니다!

개인적인 리뷰지만 루미의 세션듣고 조금은 분리를 연습하고 있어요~
간단해도 메인코드에서 빠지니까 보기 더 좋기도 하네요!

/* MARK: - SOLUTION
 
 도화지를 만들고..
 좌표값 기준으로 색칠을 하자.
 그리고 색칠된 부분만 다 더하면됨. 어차피 칸당 크기 1임.
 
 */
import Foundation

var whitePaper: [[Int]] = Array(repeating: Array(repeating: 0, count: 100), count: 100)
var area = 0

guard let paperNum = Int(readLine() ?? "") else { exit(0) }

// 좌표 입력받고 색칠하기
(0..<paperNum).forEach { _ in
    guard let points = readLine()?.components(separatedBy: " "),
          let first = Int(points[0]),
          let second = Int(points[1]) else { exit(0) }
    
    coloringPaper(first, second)
}

// 색칠함수
func coloringPaper(_ x: Int, _ y: Int) {
    for i in 0..<10 {
        for j in 0..<10 {
            if whitePaper[y + i][x + j] == 0 {
                whitePaper[y + i][x + j] = 1
                area += 1
            }
        }
    }
}

print(area)

리뷰 달면서 생각이 들었는데.
각 좌표 입력을 받고 x, y 이런식으로 나눌때
나눠진 값 카운트가 2가 아닌 경우에 대한 예외처리를 하지 못했네요..!
더 클린한 코드를 짜도록 노력하겠습니다.

[YooGyeongMo]

guard let 예술입니다 진짜 사용자 실제 입력하는거 맹키로 .. 캬 ~~~~

components 와 split의 차이가 궁금해져서 또 검색을 해보았는데욧 !

와.. 역시 split은 substring이어서 안정성부분에서 더 낮네요 ...

split은 빈 요소를 무시하고 , components 는 빈 문자열도 유지하는군요 !! 헉 .... 길.... 길 !!!!!! 무서운 언더독이군뇨 !! 야레야레다 !!

“요시… 쿄와 혼키다!!!! "

참고하시면 좋을꺼같습니닷 !!!

예외처리에 대한 반성과 성찰 ..... 캬 ........ 🫠

[YooGyeongMo]

@alstjr7437 킨더 ~

for x in point[0]..<point[0] + 10 {
    for y in point[1]..<point[1] + 10 {
        if x <= 100 && y <= 100 && peper[y][x] != true {
            peper[y][x] = true
            result += 1
        }
    }
}

해당 코드에서

       if x <= 100 && y <= 100 && peper[y][x] != true {
            peper[y][x] = true

매번 if문 체크할때 한번에 해주시려는 고민이 보이시는 코드여서 좋았습니다.

추가적으로 저렇게 단순이 하나의 조건이 아닌 논리적인 조건을 여럿 더했을때 드는 추가비용과 result += 1과 peper후추 [y][x] = true를 같이 바꾼다면 기회비용이 더 많이 드는 작업일까요 ? 궁금해지네요.그래서 !! 챗쌤한테 물어봤는데예 !

증가연산은 매우 싼편인데 배열 인덱스 읽고 쓰기는 꽤나 비싼편이라고 합니다. 하지만 !! 챗이니 검색과 함께 디깅해보시죠 !!!