반응형

난이도 : 실버3

https://www.acmicpc.net/problem/1388

 

1388번: 바닥 장식

형택이는 건축가이다. 지금 막 형택이는 형택이의 남자 친구 기훈이의 집을 막 완성시켰다. 형택이는 기훈이 방의 바닥 장식을 디자인했고, 이제 몇 개의 나무 판자가 필요한지 궁금해졌다. 나

www.acmicpc.net

 

문제

형택이는 건축가이다. 지금 막 형택이는 형택이의 남자 친구 기훈이의 집을 막 완성시켰다. 형택이는 기훈이 방의 바닥 장식을 디자인했고, 이제 몇 개의 나무 판자가 필요한지 궁금해졌다. 나무 판자는 크기 1의 너비를 가졌고, 양수의 길이를 가지고 있다. 기훈이 방은 직사각형 모양이고, 방 안에는 벽과 평행한 모양의 정사각형으로 나누어져 있다.

이제 ‘-’와 ‘|’로 이루어진 바닥 장식 모양이 주어진다. 만약 두 개의 ‘-’가 인접해 있고, 같은 행에 있다면, 두 개는 같은 나무 판자이고, 두 개의 ‘|’가 인접해 있고, 같은 열에 있다면, 두 개는 같은 나무 판자이다.

기훈이의 방 바닥을 장식하는데 필요한 나무 판자의 개수를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 방 바닥의 세로 크기N과 가로 크기 M이 주어진다. 둘째 줄부터 N개의 줄에 M개의 문자가 주어진다. 이것은 바닥 장식 모양이고, '-‘와 ’|‘로만 이루어져 있다. N과 M은 50 이하인 자연수이다.

출력

첫째 줄에 문제의 정답을 출력한다.

 

 

 


나의 풀이 (DFS, 재귀함수 활용)

import sys
n, m = map(int, sys.stdin.readline().split())	# 그래프 크기 입력

# 그래프 입력 받기
graph = []
for i in range(n):
    graph.append(list(input()))

visited = [[0] * m for _ in range(n)]

# 세로 나무 판자에 대한 DFS 재귀 함수
def dfs1(r, c):
    if r >= n or c >= m:
        return False
    if visited[r][c] == 0 and graph[r][c] == '|':
        visited[r][c] = 1
        dfs1(r + 1, c)
        return True
    return False

# 가로 나무 판자에 대한 DFS 재귀 함수
def dfs2(r, c):
    if r >= n or c >= m:
        return False
    if visited[r][c] == 0 and graph[r][c] == '-':
        visited[r][c] = 1
        dfs2(r, c + 1)              
        return True
    return False

result = 0
# 전체 위치에 대해 DFS 함수 반복
for i in range(n):
    for j in range(m):
		# DFS 함수가 True를 반환하면 result += 1
        if dfs1(i, j) == True or dfs2(i, j) == True:
            result += 1
            # 해당 round의 탐색 결과를 비교하기 위해 visited를 출력
            # for k in range(n):
            #     print(visited[k])
            # print('------')

print(result)

BFS 문제를 찾아 들어가서 BFS로 풀려고 했으나,

풀이법 떠올리기도 쉽지 않고, queue를 능숙하게 구현하기도 어려워서

나도 모르게 익숙한 DFS 재귀함수로 풀이해버렸다.

 

가로 또는 세로 방향으로 이어진 나무 판자를 묶어서 1개를 count하는 것이므로,

재귀함수를 두 개 설정하여

한 개는 가로 나무판자의 같은 방향 여부를 오른쪽으로 가면서 탐색하도록,

다른 한 개는 나무판자의 같은 방향 여부를 아래쪽으로 가면서 탐색하도록 구현하였다.

오른쪽과 아래쪽으로 한정하지 않고, 상하 또는 좌우를 탐색하도록 구현했어도,

어차피 이미 탐색한 결과가 기록되어 왼쪽 또는 위쪽으로 움직이는 일은 없었을 것이다.

(근데 이건 다른 DFS 문제도 마찬가지 아닌가..?)

 

남의 풀이가 궁금해진다.

 

 

 

 

 

남의 풀이1 (BFS 활용)

from collections import deque

n, m = map(int, input().split())	# 그래프 크기 입력
result = 0

graph = [list(input()) for _ in range(n)]	# 나무 판자 그래프 정보 입력
visited = [[0] * m for _ in range(n)]	# 방문 여부 그래프 초기화

# BFS 함수 선언
def bfs(r, c):
    queue = deque([(r, c)])
    
    # queue가 비어있지 않다면 계속 반복
    while queue:
        r, c = queue.popleft()
		# 위치가 오류라면 continue
        if r < 0 or r >= n or c < 0 or c >= m:
            continue
		# 이미 방문한 위치라면 continue
        if visited[r][c] == 1:
            continue
		
        # 가로 판자에 대한 로직
        if graph[r][c] == '-':
            visited[r][c] = 1	# 방문 정보 저장
            # 좌 또는 우에 대하여, 가능한 위치인지 판단하고
            # 같은 방향의 나무 판자라면 queue에 추가
            if c - 1 >= 0:
                if graph[r][c - 1] == '-':
                    queue.append((r, c - 1))
            if c + 1 < m:
                if graph[r][c + 1] == '-':
                    queue.append((r, c + 1))
                    
		# 세로 판자에 대한 로직 - 가로와 동일
        if graph[r][c] == '|':
            visited[r][c] = 1
            if r - 1 >= 0:
                if graph[r - 1][c] == '|':
                    queue.append((r - 1, c))
            if r + 1 < n:
                if graph[r + 1][c] == '|':
                    queue.append((r + 1, c))
            
# 전체 위치에 대해 BFS 함수 적용
for i in range(n):
    for j in range(m):
        if visited[i][j] == 0:
            bfs(i, j)
            result += 1

print(result)

BFS와 큐 자료구조를 이용한 풀이이다.

확실히 DFS, 재귀함수로 푼 것이나 로직은 큰 차이가 없다.

 

어떤 알고리즘을 사용했을 때 탐색이 일어나는 순서와 로직이 머릿속으로 그려지기만 한다면,

가능한 문제에서는 어느 알고리즘을 사용해도 상관 없는 듯하다.

 

 

 

 

 

 

남의 풀이2 (알고리즘 활용 X)

# 방 바닥의 세로 크기 n, 가로 크기 m
n,m = map(int, input().split())
graph = [] 	# 2차원 리스트의 맵 정보 저장할 공간
for _ in range(n):
    graph.append(list(input()))
 
# '-'모양의 나무 판자 개수 계산
count = 0
for i in range(n):
    a = ''
    for j in range(m):
        if graph[i][j] == '-':
            if graph[i][j] != a:
                count += 1
        a = graph[i][j]
 
# 'ㅣ'모양의 나무 판자 개수 계산
for j in range(m):
    a = ''
    for i in range(n):
        if graph[i][j] == '|':
            if graph[i][j] != a:
                count += 1
        a = graph[i][j]
 
print(count)

와 .. 너무 간단하다.

5 x 7 크기의 그래프를 가정하면

각 행을 오른쪽으로, 각 열을 아래쪽으로 총 12번 이동하면서

연결된 판자는 1개로 세고, 다른 방향의 판자가 나오면 판별자를 초기화하는 식으로 구현한 풀이이다.

 

간단한 구현 문제가 되었다..

 

 

 

 

 

반응형
반응형

 

난이도 : 실버2

https://www.acmicpc.net/problem/1012

 

1012번: 유기농 배추

차세대 영농인 한나는 강원도 고랭지에서 유기농 배추를 재배하기로 하였다. 농약을 쓰지 않고 배추를 재배하려면 배추를 해충으로부터 보호하는 것이 중요하기 때문에, 한나는 해충 방지에 

www.acmicpc.net

 

 

 

문제

차세대 영농인 한나는 강원도 고랭지에서 유기농 배추를 재배하기로 하였다. 농약을 쓰지 않고 배추를 재배하려면 배추를 해충으로부터 보호하는 것이 중요하기 때문에, 한나는 해충 방지에 효과적인 배추흰지렁이를 구입하기로 결심한다. 이 지렁이는 배추근처에 서식하며 해충을 잡아 먹음으로써 배추를 보호한다. 특히, 어떤 배추에 배추흰지렁이가 한 마리라도 살고 있으면 이 지렁이는 인접한 다른 배추로 이동할 수 있어, 그 배추들 역시 해충으로부터 보호받을 수 있다. 한 배추의 상하좌우 네 방향에 다른 배추가 위치한 경우에 서로 인접해있는 것이다.

한나가 배추를 재배하는 땅은 고르지 못해서 배추를 군데군데 심어 놓았다. 배추들이 모여있는 곳에는 배추흰지렁이가 한 마리만 있으면 되므로 서로 인접해있는 배추들이 몇 군데에 퍼져있는지 조사하면 총 몇 마리의 지렁이가 필요한지 알 수 있다. 예를 들어 배추밭이 아래와 같이 구성되어 있으면 최소 5마리의 배추흰지렁이가 필요하다. 0은 배추가 심어져 있지 않은 땅이고, 1은 배추가 심어져 있는 땅을 나타낸다.

1 1 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 1 1 0 0 0 1 1 1
0 0 0 0 1 0 0 1 1 1

입력

입력의 첫 줄에는 테스트 케이스의 개수 T가 주어진다. 그 다음 줄부터 각각의 테스트 케이스에 대해 첫째 줄에는 배추를 심은 배추밭의 가로길이 M(1 ≤ M ≤ 50)과 세로길이 N(1 ≤ N ≤ 50), 그리고 배추가 심어져 있는 위치의 개수 K(1 ≤ K ≤ 2500)이 주어진다. 그 다음 K줄에는 배추의 위치 X(0 ≤ X ≤ M-1), Y(0 ≤ Y ≤ N-1)가 주어진다. 두 배추의 위치가 같은 경우는 없다.

출력

각 테스트 케이스에 대해 필요한 최소의 배추흰지렁이 마리 수를 출력한다.

 

 

 


나의 풀이

import sys
sys.setrecursionlimit(10000)

t = int(input())	# 테스트 케이스 개수
result_list = [0 for i in range(t)]	# 출력을 위한 리스트 선언

# 상하좌우 위치에 대해 재귀함수를 호출하는 dfs 함수 선언
# 특정 위치에 배추가 있을 때(값이 1일 때)만 작동
# 탐색한 곳의 값을 0으로 변경
def dfs(x, y):
    # print('x, y in dfs :', x, y)
    if x < 0 or x >= m or y < 0 or y >=n:
        return False
    if graph[y][x] == 1:
        graph[y][x] = 0
        dfs(x - 1, y)
        dfs(x + 1, y)
        dfs(x, y - 1)
        dfs(x, y + 1)
        return True
    return False

# 테스트 케이스 개수 만큼 로직 작동
for p in range(t):
    m, n, k = map(int, sys.stdin.readline().split())	# 그래프의 가로, 세로 길이와 배추 개수
    graph = [[0 for x in range(m)] for y in range(n)]

	# 배추 심기
    for _ in range(k):
        x, y = map(int, sys.stdin.readline().split())
        graph[y][x] = 1

    result = 0
    # dfs로 탐색 결과가 True이면(해당 구역의 인접 배추를 모두 탐색했으면) 결과를 + 1
    for i in range(m):
        for j in range(n):
            if dfs(i, j) == True:
                result_list[p] += 1

# 테스트 케이스 개수만큼의 결과를 출력
for i in range(t):
    print(result_list[i])

 

input() 함수를 사용했더니 함수가 굉장히 많이 호출되어 실행 시간이 많이 걸렸다.

sys.stdin.readline()으로 대체했더니 실행 시간이 340ms 에서 84ms로 감소했다.

 

DFS를 활용한 해당 풀이에 대해서는 문제 없이 잘 푼 것 같다.

 

 

 

 

남의 풀이

import sys

def dfs(lst,visited, r, c):
    stack = [(r,c)]
    visited[r][c] = 1
    while(stack):
        r,c =stack.pop()
        dr = [-1,0,1,0]
        dc = [0,-1,0,1]
        for i in range(4):
            nr = r+dr[i]
            nc = c+dc[i]
            if 0<=nr<M and 0<=nc<N and not visited[nr][nc] and lst[nr][nc] ==1:
                stack.append((nr,nc))
                visited[nr][nc] =1

                
T = int(input())
for i in range(T):
    cnt = 0
    M, N, K = map(int,sys.stdin.readline().split())
    lst = [[0]*N for i in range(M)]
    visited = [[0]*N for i in range(M)]
    for i in range(K):
        r,c = map(int,sys.stdin.readline().split())
        lst[r][c] = 1
    for r in range(M):
        for c in range(N):
            if not visited[r][c] and lst[r][c] ==1:
                dfs(lst, visited, r,c)
                cnt += 1
    print(cnt)

아래 부분은 나의 풀이와 거의 똑같다.

다른 점은, lst와 visited로 배추 리스트와 방문 리스트를 분리해서 사용했다는 것이다.

 

dfs 함수 로직이 다른데,

1. 재귀함수가 아닌 스택 구조를 사용했다.

2. (재귀함수가 아니니 당연히) r, c의 변화량을 리스트로 사용하였다.

 

 

+ x, y를 위치 변수로 사용하는 게 수학에서의 좌표계와 혼동이 되는 것 같다.

r, c을 사용하는 버릇을 들여야겠다.

 

 

 

 

 

 

 

반응형
반응형

numpy 라이브러리를 사용할 때는 zeros 메서드로 쉽게 만들었던 영행렬을

코딩테스트 문제 풀이에서는 어떻게 사용할지 감이 잡히지 않아 찾아보았다.

 

# graph1, graph2는 같은 결과
graph1 = [[0 for x in range(m)] for y in range(n)]
graph2 = [[0] * m for _ in range(n)]

위와 같이 graph를 선언하면

n x m 의 영행렬(zero matrix)를 선언할 수 있다.

1 x m(columns) 의 영행렬을 n번(rows) 선언하는 것과 마찬가지이다.

반응형
반응형

 

 

 

 

기본적인 자료구조인 스택, 큐를 python으로 구현하는 방법을 정리해보려 한다.

 

 

스택(stack) :

- 먼저 들어온 것이 나중에 나가는 자료구조

- 선입후출(FILO: First In Last Out)

- 박스쌓기로 기억 (먼저 쌓은 박스가 가장 아래에 위치)

- 단순한 list method(append, pop) 사용으로 구현!

 

 

Python으로 스택(stack) 구현

stack = []

stack.append(5)	# 각 연산 시간복잡도 O(1)
stack.append(2)
stack.append(3)
stack.append(7)
stack.pop()
stack.append(1)
stack.append(4)
stack.pop(5)

print(stack)	# 최하단 원소부터 출력, [5, 2, 3, 1]
print(stack[::-1])	# 최상단 원소부터 출력, [1, 3, 2, 5]

위에 있는 그림처럼, 오른쪽에서 왼쪽으로 들어가는 기다란 관을 떠올리면 연상이 쉽다.

 

 

 

 

큐(queue) :

- 먼저 들어온 것이 먼저 나가는 자료구조

- 선입선출(FIFO: First In First Out)

- 입구와 출구가 뚫려있는 터널로 기억 (또는 리그오브레전드 큐(대기열) ㅋㅋ)

- collections 라이브러리의 'deque' 모듈을 사용하여 구현!

 

 

 

Python으로 큐(queue) 구현

from collections import deque

queue = deque()

queue.appned(5)	# 각 연산 시간복잡도 O(1)
queue.appned(2)
queue.appned(3)
queue.appned(7)
queue.popleft()
queue.appned(1)
queue.appned(4)
queue.popleft()

print(queue)	# 먼저 들어온 순서대로 출력, deque([3, 7, 1, 4])
queue.reverse()
print(queue)	# 나중에 들어온 순서대로 나열, deque([4, 1, 7, 3])

(reverse를 하지 않은 기준으로)

오른쪽에서 왼쪽으로 향하는 터널을 생각하면 연상이 쉽다.

 

단순 리스트로 큐를 구현하게 되면,

pop() 메서드에 index를 입력하고,

해당 인덱스 값을 반환한 후 조정하는 과정에서

O(k)의 시간복잡도가 발생하므로,

큐는 deque 모듈을 사용하는 것이 좋다.

 

 

 

 

 

 

 

참고 자료 :

https://www.youtube.com/watch?v=7C9RgOcvkvo 

 

 

 

 

 

반응형
반응형

 

https://www.acmicpc.net/problem/2839

 

2839번: 설탕 배달

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그

www.acmicpc.net

 

문제 설명

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그램 봉지와 5킬로그램 봉지가 있다.

상근이는 귀찮기 때문에, 최대한 적은 봉지를 들고 가려고 한다. 예를 들어, 18킬로그램 설탕을 배달해야 할 때, 3킬로그램 봉지 6개를 가져가도 되지만, 5킬로그램 3개와 3킬로그램 1개를 배달하면, 더 적은 개수의 봉지를 배달할 수 있다.

상근이가 설탕을 정확하게 N킬로그램 배달해야 할 때, 봉지 몇 개를 가져가면 되는지 그 수를 구하는 프로그램을 작성하시오.

(입력 : 첫째 줄에 N이 주어진다. (3 ≤ N ≤ 5000))

 

 

 

 

나의 풀이

N = int(input())

five = N // 5 + 1
three = N // 3 + 1
result = 0
end_point = False

for i in range(five + 1):
  if end_point == True:
    break
  for j in range(three):
    if N == (((five-i) * 5) + (j * 3)):
      result = (five - i) + j
      end_point = True
      break

if result == 0:
  result = -1
  
print(result)

five와 three는 각각 5킬로그램 봉지와 3킬로그램 봉지의 최대 개수 + 1 이다

5킬로그램 봉지 개수가 five 이하이고, 3킬로그램 봉지 개수가 three 이하일 때,

정확히 N킬로그램을 표현하는 경우 중, 5킬로그램 봉지 개수가 가장 큰 경우를 찾는 알고리즘을 작성했다.

 

그리디 문제로 인식했으나, 풀이는 그리디 알고리즘을 사용했다고 보기가 좀 그렇다.

찾아보니 아직 안 배운 동적 프로그래밍(DP)에 가까운 것 같다.

 

 

 

남의 풀이

def sugar_bag(N):
    bag_3 = 0
    bag_5 = N // 5
    r = N % 5
    while (bag_5 >= 0):
        if r % 3 == 0:
            bag_3 = r // 3
            return bag_3 + bag_5
        bag_5 -= 1
        r += 5
    return -1
    
    
N = int(input())
print(sugar_bag(N))

3킬로그램, 5킬로그램 봉지 개수를 각각 bag_3, bag_5로 정의한다.

N을 5로 나누고 나눈 나머지를 r로 정의한다.

 

r을 3으로 나눴을 때,

나누어 떨어진다면 바로 bag_3, bag_5의 합을 반환한다.

나누어 떨어지지 않는다면 나머지에 5를 더하고 bag_5을 한 개 빼준다.

 

 

확실히 그리디 알고리즘을 사용한 풀이다.

3과 5의 최소공배수인 15에 대해,

5킬로그램 봉지 3개를 사용하는 것이 무조건 이득이므로

그리디 알고리즘 사용 형태에 해당한다.

 

 

 

 

참고 자료 : https://www.acmicpc.net/source/17359883

 

반응형
반응형

 

sum(), min(), max(), eval() - 합, 최대값, 최소값, 문자열을 식으로

# sum()
result = sum([1, 2, 3, 4, 5])
print(result) # 15

# min(), max()
min_result = min(7, 3, 5, 2)
max_result = max(7, 3, 5, 2)
print(min_result, max_result) # 2 7

# eval()
result = eval("(3+5)*7")
print(result) # 56

sum()은 합, min()과 max()는 최소, 최대값을 추출한다.

eval()은 문자열로 된 식(코드)을 계산한다.

 

 

 

sorted() - 정렬된 새로운 리스트 반환

# sorted()
result = sorted([9, 1, 8, 5, 4])
reverse_result = sorted([9, 1, 8, 5, 4], reverse=True)
print(result) # [1, 4, 5, 8, 9]
print(reverse_result) # [9, 8, 5, 4, 1]

sorted()는 리스트(또는 다른 자료형)를 정렬한다.

reverse 인자는 내림차순 여부를 결정한다. (없으면 오름차순)

 

리스트의 sort() 메서드와 다른 점은, sorted() 함수는 새로운 리스트를 생성한다는 것이다.

 

 

 

 

 

itertools permutaions(), combinations() - 순열, 조합

from itertools import permutations
data = ['A', 'B', 'C']

result = list(permutations(data, 3))
print(result)
# [('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]

permutations(list, n)은 list에서 순서를 고려하여 n개를 추출한 경우의 수를 생성해준다.

 

from itertools import combinations
data = ['A', 'B', 'C']

result = list(combinations(data, 2))
print(result)
# [('A', 'B'), ('A', 'C'), ('B', 'C')]

combinations(list, n)은 list에서 순서를 고려하지 않고 n개를 추출한 경우의 수를 생성해준다.

 

중복 순열과 중복 조합을 나타내는 product(list, n)과 combinations_with_replacement(list, n) 함수도 존재한다.

 

 

 

Counter - 성분의 개수를 세어주는 클래스

from collections import Counter

counter = Counter(['red', 'blue', 'red', 'green', 'blue', 'blue'])

print(counter['blue']) # 3
print(counter['green']) # 1
print(dict(counter)) # 딕셔너리로 반환
# {'red': 2, 'blue': 3, 'green': 1}

Counter는 리스트에서 성분의 개수를 세어주는 클래스이다.

딕셔너리 형태로 각 성분의 개수를 반환할 수도 있다.

 

 

gcd() - 최대공약수

import math

# 최소공배수(LCM)을 구하는 함수
def lcm(a, b):
	return a * b // math.gcd(a, b)
    
a = 21
b = 14

print(math.gcd(21, 14)) # 7 (최대공약수)
print(lcm(21, 14) # 42 (최소공배수)

gcd(a, b)는 a와 b의 최대공약수를 구하는 메서드이다.

최소공배수는 = (두 수의 곱) / (최대공약수) 공식에 따라 위와 같이 구할 수 있다.

(공식을 간단히 증명하자면,

A와 B의 최대공약수를 GCD라 하고, A = a x GCD, B = b x GCD 라 하자.

AB = a x b x (GCD)^2 이다.

이때, a, b, GCD는 모두 서로소 이므로, 위의 식에서 양변을 GCD로 나누면

AB/GCD = a x b x GCD 이고, 이 값은 최소공배수가 된다.)

 

 

 

 

반응형
반응형

리스트 컴프리헨션(List Comprehension)이란?

대괄호 안에 조건문과 반복문을 적용하여 리스트를 초기화하는 방법이다.

-> 코딩테스트 문제를 풀 때 유용한 문법이라고 한다.

 

 

 

 

 

사용 예시

반복문만 사용

array = [i for i in range(10)]
print(array) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

간단한 반복문으로 위와 같은 배열을 생성할 수 있다.

 

 

 

 

반복문과 조건문 사용

array = [i for i in range(10) if i % 2 == 1]
print(array) # [1, 3, 5, 7, 9]

조건문을 추가할 수 있다.

 

 

 

 

삽입 인자 변경

array = [i * i for i in range(10)]
print(array) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

리스트에 삽입할 인자를 변경할 수 있다.

 

 

 

 

2차원 배열 생성

# 모든 성분이 0인 3 x 4 크기의 2차원 배열
array = [[0] * 3 for _ in range(4)]
# [0] * 3 => [0, 0, 0]

print(array)
# [[0,0,0], [0,0,0], [0,0,0], [0,0,0]]

# 잘못된 사용
array = [[0] * 3] * 4

2차원 배열을 생성할 때 매우 유용하게 사용할 수 있다.

('_'는 0, 1, ...,  n의 값을 가질테지만, 사용하지 않는 값이라는 뜻으로 '_'로 표시한다.)

 

잘못된 사용은 [0, 0, 0]라는 배열 하나를 생성하고, 같은 위치를 참조하는 4개의 배열을 생성한다.

즉, 동일한 배열([0, 0, 0]) 하나를 세 번 참조하는 것이므로 의도와 다르다.

 

 

 

일반적 코드와의 비교

## 리스트 컴프리헨션
# 0 ~ 19까지의 홀수
array = [i for i in range(20) if i % 2 == 1]
print(array)

## 일반적인 코드
# 0 ~ 19까지의 홀수
array = []
for i in range(20) :
	if i % 2 == 1 :
    	array.append(i)
print(array)

리스트 컴프리헨션이 얼마나 간결한 기능인지 알 수 있다.

 

 

 

 

반응형

+ Recent posts