SW 역량 테스트 치르기 전 숙지하면 좋을 삼성 빈출 코드 유형 정리 🕵🏼‍♀️🌀🦈

Konseo·2023년 10월 9일

삼성 삼성빈출유형 삼성전자 삼성코테 삼성코테기출 삼성코테대비 삼성코테준비 코딩테스트 코테대비 코테준비

코테풀이

목록 보기

39/59

삼성 기출에서 자주 나오는 & 숙지하면 좋을 코드 유형들을 추려보았습니다
혹시 자주 나오는 또다른 유형이 있다면 댓글로 알려주시면 감사하겠습니다 ! 🙇🏻‍♀️

1. 회전

(1) zip() 활용해서 회전

정사각형, 직사각형 모두 적용 가능

arr = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

## zip
# 시계 방향 90 (= 반시계 방향 270)
arr_90 = list(map(list, zip(*arr[::-1])))
print(arr_90)

# 시계 방향 180 (= 반시계 방향 180)
arr_180 = [a[::-1] for a in arr[::-1]]
print(arr_180)

# 시계 방향 270 (= 반시계 방향 90)
arr_270 = [x[::-1] for x in list(map(list, zip(*arr[::-1])))[::-1]]
print(arr_270)

비교적 생각하기 쉽고 빠르게 구현할 수 있다
(+) 정사각형이 아닌 직사각형의 경우에도 배열의 인덱스 고민없이 빠르게 처리하기 좋다
(-) 메모리나 시간 복잡도 면에서는 2번 방식보다 좋지 않다

(2) 인덱스 규칙 찾아서 회전

정사각형

## 인덱싱
arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
n = 3
# 시계 방향 90 (= 반시계 방향 270)
new_90 = [[0] * n for _ in range(n)]
for i in range(n):
    for j in range(n):
        new_90[j][n - i - 1] = arr[i][j]
print(new_90)

# 시계 180 & 반시계 180
new_180 = [[0] * n for _ in range(n)]
for i in range(n):
    for j in range(n):
        new_180[n - i - 1][n - j - 1] = arr[i][j]
print(new_180)

# 시계 270 & 반시계 90
new_270 = [[0] * n for _ in range(n)]
for i in range(n):
    for j in range(n):
        new_270[n - 1 - j][i] = arr[i][j]
print(new_270)

직사각형

def rotated_90(a):
  m= len(a)
  n = len(a[0])
  result = [[0]* m for _ in range(n)] # 배열의 가로 세로 길이가 뒤바뀌는 것 주의
  for i in range(m): # 범위 주의
    for j in range(n): # 범위 주의
      result[j][m-i-1] = a[i][j]
  return result

def rotated_180(a):
  n= len(a)
  m = len(a[0])
  result = [[0]* m for _ in range(n)] 
  for i in range(n): # 범위 주의
    for j in range(m): # 범위 주의
      result[n-i-1][m-j-1] = a[i][j]
  return result

def rotated_270(a):
  n= len(a)
  m = len(a[0])
  result = [[0]* n for _ in range(m)] # 배열의 가로 세로 길이가 뒤바뀌는 것 주의
  for i in range(n): # 범위 주의
    for j in range(m): # 범위 주의
      result[m-1-j][i] = a[i][j]
  return result

a=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
print(rotated_90(a))
print(rotated_180(a))
print(rotated_270(a))

외워둔다면 해당 방식 또한 쉽고 빠르게 구현이 가능하다

2. 부분 회전

부분 회전은 말그대로 2차원배열의 특정 부분만 회전시키는 것을 말한다. 보기엔 간단해 보일 수 있어도 꼭 step 별로 구현하는 것을 추천한다. (나중에 해당 부분에서 꼬이게 되면 디버깅 하기 힘들기 때문)

# 7X7 배열
arr = [[7 * j + i for i in range(1, 8)] for j in range(7)]
new_arr = [[0] * 7 for _ in range(7)]
sy, sx = 2, 2
length = 3


# 배열의 특정 부분(정사각형)을 회전시킴
def rotate_90(sy, sx, length):
    global arr, new_arr
    # 정사각형을 시계방향으로 90도 회전
    for y in range(sy, sy + length):
        for x in range(sx, sx + length):
            # 1단계 : (0,0)으로 옮겨주는 변환을 진행함
            oy, ox = y - sy, x - sx
            # 2단계 : 90도 회전했을때의 좌표를 구함
            ry, rx = ox, length - oy - 1
            # 3단계 : 다시 (sy,sx)를 더해줌
            new_arr[sy + ry][sx + rx] = arr[y][x]

    # new_arr 값을 현재 board에 옮겨줌
    for y in range(sy, sy + length):
        for x in range(sx, sx + length):
            arr[y][x] = new_arr[y][x]
            print(arr[y][x])

rotate_90(sy, sx, length)

for i in range(len(arr)):
    print(arr[i])

원본
회전 후

3. 순열, 중복 순열, 조합, 중복 조합

삼성 코테는 itertools 라이브러리 사용 불가하다. 백트래킹으로 직접 구현해서 써야한다.

순열 (permutations)

arr = [1, 2, 3, 4]
visited = [0] * len(arr)  # visited도 전역으로 둬도 됨


def permutations(n, new_arr):
    global arr
    # 순서 상관 0, 중복 X
    if len(new_arr) == n:
        print(new_arr)
        return
    for i in range(len(arr)):
        if not visited[i]:
            visited[i] = 1
            permutations(n, new_arr + [arr[i]])
            visited[i] = 0


permutations(2, [])

순서 0, 중복 X
유일하게 visited 배열이 있음 -> 순서를 고려해야하기 때문
parameter : 뽑을 개수, 뽑힌 값을 담는 배열
전역변수 : visited 배열

중복 순열 (product)

arr = [1, 2, 3, 4]
def product(n, new_arr):
    global arr
    # 순서 상관 0, 중복 0
    if len(new_arr) == n:
        print(new_arr)
        return
    for i in range(len(arr)):
        product(n, new_arr + [arr[i]])

product(2, [])

순서 0, 중복 0
부가 조건이 없는 가장 라이트한 코드라고 생각하기
parameter : 뽑을 개수, 뽑힌 값을 담는 배열

조합 (combinations)

arr = [1, 2, 3, 4]

# 현재 인덱스 +1 만큼을 매개변수로 계속 넘겨주어야함
# 순서가 상관없고 중복 불가이기 때문에 현재 인덱스보다 같거나 작은 인덱스는 볼 필요가 없기 때문
def combinations(n, new_arr, c):
    # 순서 상관 X, 중복 X
    if len(new_arr) == n:
        print(new_arr)
        return
    for i in range(c, len(arr)):
        combinations(n, new_arr + [arr[i]], i + 1)


combinations(2, [], 0)

순서 X, 중복 X
현재 인덱스를 의미하는 매개변수가 추가됨
- 순서가 상관없고 중복 불가이기 때문에 현재 인덱스보다 같거나 작은 인덱스는 볼 필요가 없기 때문임. 따라서 재귀돌릴때 현재 인덱스+1 값을 넘김
parameter : 뽑을 개수, 뽑힌 값을 담는 배열, 현재 인덱스

중복 조합 (combinations_with_replacement)

arr = [1, 2, 3, 4]

def combinations_with_replacement(n, new_arr, c):
    # 순서 상관 X, 중복
    if len(new_arr) == n:
        print(new_arr)
        return
    for i in range(c, len(arr)):
        combinations(n, new_arr + [arr[i]], i)


combinations_with_replacement(2, [], 0)

순서 X, 중복 0
조합과 동일하게 현재 인덱스를 의미하는 매개변수가 추가됨
- 중복 가능하므로 재귀 돌릴때 현재 인덱스+1가 아닌 현재 인덱스 값을 그대로 넘김
parameter : (뽑을 개수, 뽑힌 값을 담는 배열, 현재 인덱스)

4. 중력

바닥까지 하강

arr = [[0, 1, 0], [1, 0, 1], [0, 1, 0], [0, 0, 1], [0, 1, 0]]

print("기존")
for i in range(len(arr)):
    print(arr[i])


def gravity(arr):
    n = len(arr)
    m = len(arr[0])
    for i in range(m):
        write = n-1
        for j in range(n-1,-1,-1):
            if arr[j][i]==1:
                if write == j:
                    write-=1
                    continue
                arr[write][i],arr[j][i]=1,0
                write-=1

gravity()

print("변화")
for i in range(len(arr)):
    print(arr[i])

열 단위 write 포인터 방식
위에서 내려오는 블록들을 바닥부터 차곡차곡 쌓기
장점: 스왑/버블 없이 1패스로 정리 → 구현도 명확, 성능도 좋음
0/1이 아니라 임의의 값(예: 2,3…)도 자연스럽게 내려감

5. 달팽이(나선형) 배열 🐌

2차원 배열에서 시작 지점을 기준으로 나선형으로 값에 접근하는 코드 유형이다
어딘가에선 토네이도 🌪 코드라고도 불리는 듯 하다

안에서 밖으로


def spiral_from_center(n: int):
    """센터에서 시작해 좌→하→우→상 순으로 나선 채우기 (센터는 0 유지)"""
    arr = [[0]*n for _ in range(n)]
    y = x = n // 2           # 시작: 중앙
    num = 0                  # 채울 값 (센터는 0 유지)
    dist = 1                 # 한 번에 이동할 칸 수
    d_idx = 0                # 현재 방향 인덱스 (0:좌,1:하,2:우,3:상)
    dy=[0,1,0,-1]
    dx=[-1,0,1,0]
    # 전체 칸 n*n 중, 센터를 비워 두면 채워야 할 칸은 n*n - 1
    while num < n*n - 1:
        # 같은 dist로 두 번 진행하면(좌→하) dist를 1 늘리는 패턴
        for _ in range(2):
            _dy=dy[d_idx]
            _dx=dx[d_idx]
            for _ in range(dist):
                y += _dy
                x += _dx
                if 0 <= y < n and 0 <= x < n:
                    num += 1
                    arr[y][x] = num
            d_idx = (d_idx + 1) % 4
        dist += 1
    return arr

arr=spiral_from_center(5)

for i in range(len(arr)):
    print(arr[i])

돌아가는 순서는 문제마다 다를 수 있다 (위 코드는 좌->하->우->상 방향)

밖에서 안으로

def spiral_from_corner(n: int):
    """(0,0)에서 시작해 우→하→좌→상으로 바깥에서 안쪽으로 채우기"""
    arr = [[0]*n for _ in range(n)]
    y = x = 0
    num = 1
    dirs = [(0,1),(1,0),(0,-1),(-1,0)]  # 우, 하, 좌, 상
    d_idx = 0

    # 바깥-테두리 길이를 줄여가며 진행
    top, left, bottom, right = 0, 0, n-1, n-1
    while top <= bottom and left <= right:
        # 우
        for c in range(left, right+1):
            arr[top][c] = num; num += 1
        top += 1
        # 하
        for r in range(top, bottom+1):
            arr[r][right] = num; num += 1
        right -= 1
        if top > bottom or left > right: break
        # 좌
        for c in range(right, left-1, -1):
            arr[bottom][c] = num; num += 1
        bottom -= 1
        # 상
        for r in range(bottom, top-1, -1):
            arr[r][left] = num; num += 1
        left += 1
    return arr

밖에서 안으로 들어가는 것은 더욱 쉽다. 별도의 move_count나 dist를 두지 않아도 되기 때문이다.
프로그래머스에 정수를 (0,0)에서부터 나선형으로 배치하는 문제와 같은 문제라고 생각하면 된다.

6. 이동 중 벽에 부딪혀서 방향이 전환되는 경우

낚시왕 문제는 아래 방식대로 코드를 짜지 않으면 시간초과가 난다. 아래 코드의 경우 한 번에 코드를 이해하기 힘들 수 있는데 해당 영상이 이해하는 데 도움이 될 수 있으니 참고해 보면 좋을 듯 하다

# d: 1=위, 2=아래, 3=오른쪽, 4=왼쪽
dr = [0, -1, 1, 0, 0]
dc = [0,  0, 0, 1,-1]

def move(r, c, s, d, R, C):
    if d in (1, 2):                  # 위/아래
        cycle = 2 * (R - 1) if R > 1 else 1
        steps = s % cycle
        for _ in range(steps):
            if r == 0 and d == 1:    # 맨 위에서 위로 가려면 튕겨서 아래로
                d = 2
            elif r == R-1 and d == 2: # 맨 아래에서 아래로 가려면 튕겨서 위로
                d = 1
            r += dr[d]
    else:                            # 좌/우
        cycle = 2 * (C - 1) if C > 1 else 1
        steps = s % cycle
        for _ in range(steps):
            if c == 0 and d == 4:    # 맨 왼쪽에서 왼쪽이면 → 오른쪽으로 튕김
                d = 3
            elif c == C-1 and d == 3: # 맨 오른쪽에서 오른쪽이면 → 왼쪽으로 튕김
                d = 4
            c += dc[d]
    return r, c, d

7. 배열 한 칸씩 돌리기

백준의 배열돌리기1 문제 풀이이다 !

from collections import deque

def rotate_matrix(arr, R):
    N = len(arr)
    M = len(arr[0])
    layers = min(N, M) // 2  # 레이어 개수
    
    for layer in range(layers):
        q = deque()
        
        # 1. 레이어 껍질 꺼내기
        # 위쪽 행
        for y in range(layer, M-layer):
            q.append(arr[layer][y])
        # 오른쪽 열
        for x in range(layer+1, N-layer-1):
            q.append(arr[x][M-layer-1])
        # 아래쪽 행
        for y in range(M-layer-1, layer-1, -1):
            q.append(arr[N-layer-1][y])
        # 왼쪽 열
        for x in range(N-layer-2, layer, -1):
            q.append(arr[x][layer])
        
        # 2. 회전 (R만큼 왼쪽으로)
        q.rotate(-(R % len(q)))
        
        # 3. 다시 채워넣기
        # 위쪽 행
        for y in range(layer, M-layer):
            arr[layer][y] = q.popleft()
        # 오른쪽 열
        for x in range(layer+1, N-layer-1):
            arr[x][M-layer-1] = q.popleft()
        # 아래쪽 행
        for y in range(M-layer-1, layer-1, -1):
            arr[N-layer-1][y] = q.popleft()
        # 왼쪽 열
        for x in range(N-layer-2, layer, -1):
            arr[x][layer] = q.popleft()
    return arr