• 활동기간 : 약 4개월
• 프로그램 소개 : 멘토 - 멘티가 하나의 오픈소스 프로젝트를 진행하면서 기여하는 프로그램이다. 작년에 이 프로그램의 존재를 알게 되었고 다음 회차에 참여해보고 싶었는데 공고가 떠서 지원했고 감사하게도 멘티로 선정되어서 이번에 활동할 수 있게 되었다.
• 홈페이지 : 2021 오픈소스 컨트리뷰션 아카데미 노션 페이지

참여하고 싶었던 이유

스트레스 없이 개발활동을 할 수 있을 것 같았다. 프로젝트나 과제를 하다보면 해치우는 식으로 코딩을 하게된다. 만약에 내가 A라는 기능을 맡았으면 이 기능이 돌아가기만 하면 되는 식으로 코딩을 하는거다. 거의 99% 구글링으로 이어붙여놓는 식ㅠ 어쨌든 동작만하면 된다는 식의 개발 경험이 많아지다보니 개발을 한다라기 보다는 그냥 타이핑 친다는 느낌이 많이 들었다. 그래서 순수한 개발활동에 집중하고 싶었다. 물론 정해진 기간이 있고 개선해야할 이슈들이 있을거지만 좀 더 자유로운 형태로 개발활동을 할 수 있다는 점이 매력적이었다.

우선 오픈소스 프로젝트를 하기 위해서는 기존의 프로젝트 코드를 이해해야하고 새로운 PR이 생기면 코드리뷰를 하면서 기존의 것에서 어떤 점들이 변경되는지 알아야 한다. 이러한 과정 자체가 개발에 몰두할 수 있는 환경이라고 생각했다. 일단 코드를 뜯어보면서 이해하는 하는 과정이 필수적이기 때문이다.

진행 방식

• 기존 프로젝트 깃허브 저장소 fork
• 각자 맡은 이슈 사항들을 토대로 개발
• 변경사항 commit
• PR 작성
• 코드리뷰
• merge

대략 이런식으로 진행되고, 깃으로 협업하는 것과 크게 다른 점은 없다.

지금까지의 진행 상황

• 발대식
• 깃허브 저장소 fork

앞으로 일정

• 조 배정
• 이슈 할당 받기
• 개발 환경 셋팅
• PR 날리기~

문제 1.

• 분류 : BFS
• 유사문제 : 백준 물통

l1, l2 = map(int,input().split())
from collections import deque
que = deque([(0,0)])
visited =[ [False] * (l2 + 1) for _ in range(l1 + 1)]
visited[0][0] = True
ans = set()

def add_que(node):
    if visited[node[0]][node[1]] == False:
        visited[node[0]][node[1]] = True
        que.append(node)

while que :
    now = que.popleft()

    ans.add(now[0])
    ans.add(now[1])

    add_que((l1,l2))
    add_que((l1, now[1]))
    add_que((now[0], l2))
    add_que((0, now[1]))
    add_que((now[0], 0))
    add_que((0,0))

    amount = min(l2-now[1], now[0])
    add_que((now[0]-amount, now[1]+amount))
    amount = min(l1-now[0], now[1])
    add_que((now[0] +amount, now[1]-amount))

ans.remove(0)
[ print(i, end=' ') for i in sorted(ans)]

풀이과정

• 두 개의 물통 A와 B가 있다고 가정한다.
• 가능한 액션

    1. 물통 가득 채우기
    2. 물통 다 비우기
    3. 다른 물통으로 물 옮기기 

• (a물통에 남은 양, b물통에 남은양)으로 상태 체크 여부를 확인한다.

1. (0,0)으로 큐를 초기화한다.
2. 큐에서 꺼낸 노드(현재)에 가능한 액션을 모두 취한다
3. visited을 통해 액션을 취한 뒤의 노드가 이미 조회된 노드인지 판별한다.
4. 조회된 적 없으면 큐에 push한다.
5. pop한 노드의 값들을 set에 add하여 중복을 제거한다.
6. 마지막에 초기화를 위해 셋팅했던 0을 set에서 지우고 정렬하여 출력한다.

문제 2.

• 분류 : 투포인터, 슬라이딩 윈도우

road = list(input())
road = list(map(int, road))
n = int(input())
start, end = 0, 0
repair = [-1]

for i in range(len(road)):
    if road[i] == 0:
        if len(repair) == n+1:
            repair.pop(0)
        repair.append(i)

    l1 = end - start
    l2 = i+1 - repair[0]

    if l2 > l1 :
        start = repair[0] + 1
        end = i + 1

print(end-start)

풀이과정

• start, end는 가장 긴 배열의 시작과 끝을 가리킨다.
• repair에는 0 -> 1로 변경된 인덱스가 저장된다. (처음에는 없으므로 -1로 셋팅)
• l1 : 현재 start, end 포인터가 가리키는 배열의 길이
• l2 : 수정된 0 다음 부터 ~ 현재노드 포함한 길이

1. 현재 노드가 0 이면 repair에 넣는다. 길이가 n+1이면 맨 앞의 노드를 pop한다. (크기가 항상 n+1유지, 왜 n+1이냐면 가장 앞쪽의 수정된 노드를 알고 있어야 하기 때문이다. )
2. 현재 end- start 길이 vs 가장 왼쪽의 수정된 노드 다음부터 ~ 현재 노드 포함한 길이 비교
3. 후자가 더 크다면, start, end 갱신
4. end가 마지막노드때까지 반복
5. end-start하면 가장 큰 부분 배열의 길이를 출력하게 된다.

알고리즘 문제 풀이

• 문제 : 다리 놓기
• 해결 : solved
• 분류 : 조합, DP

풀이 방법(1) - 조합

1. 조합 공식을 사용한다
2. n!이 사용되는데 여기서 DP로 n까지의 n! 각 값들을 배열을 이용해 구해놓는다.
3. dp로 만들어 놓은 배열을 이용하여 공식에 따라 계산한다.

풀이 방법(2) - DP

1. n까지의 배열을 초기화하고 각 인덱스는 x개의 동쪽 사이트가 있을 경우로 정의한다.
2. dp[i] 는 i번째 사이트를 포함하는 경우의 수 + 포함하지 않는 경우의 수

   f(n, k) = f(n-1, k) + f(n-1, k-1)

3. dp 배열의 마지막 원소를 출력한다.

소스코드

T = int(input())
for _ in range(T):
    N, M = map(int, input().split())
    dp = [[1] * (M+1) for _ in range(N+1)]

    for i in range(1, N+1):
        for j in range(1, M+1):
            if i > j :
                dp[i][j] = 0
            elif i == j :
                dp[i][j] = 1
            else:
                dp[i][j] = dp[i][j-1] + dp[i-1][j-1]
    print(dp[-1][-1])

알고리즘 문제 풀이

• 문제 : 오큰수
• 해결 : unsolved
• 분류 : 스택

내 풀이 방법

• 일단 스택인 것은 알았다.

• 배열을 for문으로 순회하면서 스택에는 해당노드보다 더 큰 값들만 있게한다.

• top이 현재 노드 보다 크거나 스택이 비었으면 -1

• 현재 노드보다더 작은 값이 있다면 smaller 스택에 push

• 스택을 끝까지 순회하고 스택이 비었으면 smaller의 값들을 다시 넣어줌

• 소스코드

  import copy
  N = int(input())
  arr = list(map(int, input().split()))
  stack = copy.deepcopy(arr[::-1])
  smaller = []
  nums = []
  for i in range(N-1):
    while stack:
        top = stack[-1]
        if top < arr[i] :
            smaller.append(top)
            stack.pop()
        elif top == arr[i]:
            stack.pop()
            continue
        elif top > arr[i]:
            break
  
    if stack != []:
        nums.append(str(stack[-1]))
        while smaller:
            smaller.pop()
    else:
        nums.append(str(-1))
        while smaller:
            stack.append(smaller.pop())
  

print(' '.join(nums+['-1']))

## 정답 풀이
> - 스택에는 인덱스를 저장한다 
- 현재 노드와 바로 오른쪽 노드만 비교한다. (스택을 순회할 필요x) 
- 비교하여 오큰수를 찾았다면 해당 인덱스를 스택에서 pop 
- 오큰수를 찾지 못했다면 pop하지 않고 계속 인덱스를 push 한다. 
- 만약 스택에 [5,3,4] 가 있고 현재 노드가 6일 때 스택에 있는 모든 수의 오큰수는 6이 된다. 따라서 pop을 해주면서 오큰수를 갱신해준다. 그리고 6을 push한다. 
- 다음(6의 오른쪽) 노드는 스택의 top (=6)을 peek해서 비교하면서 반복한다. 

## 정답 소스코드 
```python

N = int(input())
arr = list(map(int, input().split()))
stack = [0]
nums = [-1]*N

for i in range(1, N):
    while stack and arr[stack[-1]] < arr[i]:
        nums[stack.pop()] = arr[i]
    stack.append(i)

print(*nums)

놓친 점

• 스택을 2개를 놓고 현재 노드보다 큰 값들, 현재 노드보다 작은 값들을 저장하려고 했던 점
• 인덱스가 아니라 값 그자체를 저장했던점.

스택 자료구조의 특징을 잘 활용하기가 어렵다.

알고리즘 문제 풀이

• 문제 : 문제집
• 해결 : solved
• 분류 : 위상정렬, 우선순위큐

풀이 과정

1. 입력 차수를 배열에 저장한다. (자신의 노드로 화살표가 들어오는 횟수)
2. 차수가 0인 노드들을 힙에 push
3. while문을 순회하면서 pop된 node에 연결된 노드들의 차수를 검사한다.
4. 0인 차수들은 힙에 push, 현재 노드의 연결된 모든 노드들의 차수를 1씩 차감
5. 힙에서 꺼낸 순서대로 출력한다.

   힙에 있는 노드들은 모두 입력 차수가 0임이 보장된다.

소스코드

N, M = map(int, input().split())
degree =[0] * (N+1)
graph =[[] for _ in range(N+1)]

for i in range(M):
    prev, post = map(int, input().split())
    degree[post] += 1
    graph[prev].append(post)

import heapq

heap = []
for i in range(1, N+1):
    if degree[i] == 0:
        heap.append(i)

heapq.heapify(heap)

while heap:

    node = heapq.heappop(heap)
    print(node, end=' ')
    for n in graph[node]:
        degree[n] -= 1
        if degree[n] == 0 :
            heapq.heappush(heap, n)

알고리즘 문제풀이

• 문제 : 수열의 합
• 해결 : solved
• 분류 : 수학(수열)

풀이방법

1. 등차수열 공식을 활용하여 식을 만든다. a + (n-1)d
2. L부터 100까지 순회하면서 수열의 합이 특정값을 만족하는지 검사한다.
3. 결과를 출력한다.

소스코드

N, L = map(int, input().split())
x = []

def get_arr(length, N):
    x = N - (length * (length+1) // 2)
    return x / length

for i in range(L, 101):

    a = get_arr(i, N)
    if int(a) == a :
        a = int(a)
        sub_sum = sum(range(a+i+1)) - sum(range(a+1))
        if sub_sum == N :
            x = (list(range(a + 1, a + i + 1)))
            x = list(map(str, x))
            break

print(' '.join(x) if x != [] and len(x) <= 100 else -1)

알고리즘 문제풀이

• 문제 : 탑
• 해결 : 시간초과
• 분류 : 스택

초기 풀이방법(시간초과)

1. 탑 길이들의 배열을 for문으로 돌면서 하나씩 pop한다
2. 각 탑의 길이보다 짧은 요소들은 smaller 스택에 넣는다
3. 계속 pop하면서 더 긴 요소를 찾으면 smaller 스택에 있는 요소들을 다시 원래 리스트에 이어 붙인다.
4. 더 긴 요소의 인덱스를 결과 배열에 저장한다.

시간 초과 이유 : 해당 요소보다 더 작은 요소들은 그냥 pop해버리고 따로 저장해두지 않아도 된다. 그런데 따로 저장해두고 다시 이어 붙이는 과정이 있어서 시간초과가 발생했다.

개선 풀이방법

1. 각 요소들을 for문으로 순회한다. 처음부터
2. 스택에는 이전 요소들의 값들이 저장되어 있다.
3. 스택에 아무것도 없다면 0 출력
4. 스택에 요소가 존재한다면 자신보다 작은 요소들은 pop하여 없앤다. 큰 요소가 존재할 경우 해당 인덱스 출력
5. 현재 요소를 스택에 push

소스코드

N = int(input())
H = list(map(int, input().split()))
stack = []
for i in range(N):
    while stack:
        top = H[stack[-1]]
        if top > H[i]:
            break
        stack.pop()
    if stack == []:
        print(0)
    else:
        print(stack[-1]+1)
    stack.append(i)

왜 스택 자료구조를 이용해야되는지

문제에서 레이저는 왼쪽으로만 발사된다고 했다. 즉 방향이 하나뿐이다. 해당 노드 기준으로 왼쪽에 있는 노드들 중에서 가장 가까운 큰 노드가 정답이 된다. 스택의 경우 가장 최신의 노드 (=거리가 가까운 노드)가 최상위 노드에 있다. 또한 스택은 순서가 유지된다.

느낀 점

• 스택을 사용함으로써 어떤 점을 활용할 수 있는지 모르겠다.
• 어떤 경우에 스택을 사용해야하는지
• 문자열, 괄호열 처럼 특정한 한 방향으로 순서가 이루어질 때 스택을 사용한다는 건 알겠는데 내가 스택의 특성을 잘 활용하지 못하고 있는 것 같다.

알고리즘 문제 풀이

• 링크 : 에디터
• 유형 : 자료구조, 스택
• 해결 : solved

풀이과정

1. 두 개의리스트를 만들고 A에는 입력받은 초기문자열 B에는 빈 스택.
2. 커서를 왼쪽으로 이동하면 A에서 pop한 데이터를 B 스택에 push
3. 커서를 오른쪽으로 이동하면 반대로 동작
4. 삭제와 삽입은 A에서 일어나도록.

놓친 점

• 처음에는 리스트 하나로 두고 커서의 위치를 저장하는 index 변수를 변경해가는 방식으로 처리했더니 시간초과 발생.
• 이유 : 리스트 하나로 처리하다보니 insert를 사용하게 되는데 노드를 하나 삽입시 그 뒤에 모든 노드들이 하나씩 밀려나는 연산이 필요하게 된다.
• 커서 이전/이후로 나누어서 리스트 두개로 저장한 다음 마지막에 스택부분만 거꾸로 조회해서 이어붙이면 된다.

소스코드

import sys
input = sys.stdin.readline
str = list(input().rstrip())
N = len(str)
M = int(input())
commands = [ input().rstrip().split() for _ in range(M)]
index = len(str)

def execute(str, stack, cmd, char=None):

    if cmd == 'L' and str != []:
        stack.append(str.pop())
    if cmd == 'D' and stack != []:
        str.append(stack.pop())
    if cmd == 'B' and str != []:
        str.pop()
    if cmd == 'P':
        str.append(char)

stack = []
for c in commands:
    index = execute(str=str, stack=stack, cmd=c[0], char= c[1] if len(c) ==2 else None)

print(''.join(str+stack[::-1]))

알고리즘 문제 풀이

• 링크 : 뱀
• 해결 : solved
• 시간복잡도 : O(n)
• 분류 : 구현, 덱

  풀이 과정

1. cnt를 증가시키면서 반복한다.
2. 방향을 바꿔야하면 바꾼다.
3. 현재 방향으로 한 칸 이동한다.
4. 종료 조건이면 break
5. 이동가능한 칸이면 deque에 해당 칸을 appendleft 한다.
   • 사과가 있으면 pop을 하지 않는다. = 꼬리를 옮기지 않는다.
   • 사과가 없으면 pop = 꼬리를 옮긴다.
6. 1~5번을 반복하면서 while문이 종료되면 cnt를 출력한다.

메모

• *뱀이 위치하고 있는 좌표들을 저장하는 자료구조가 deque이다. *
• 왼쪽이 머리(=appendleft) 오른쪽이 꼬리(=pop)

소스코드

N = int(input())
A = int(input())
apples = []
for _ in range(A):
    pos = list(map(int, input().split()))
    pos = list(map(lambda x : x-1, pos))
    apples.append(pos)

L = int(input())
shifts = []
for shift in range(L):
    sec, dir = input().split()
    sec = int(sec)
    shifts.append((sec, dir))

board = [[0]*N for _ in range(N)]
for a in apples:
    board[a[0]][a[1]] = 1
D = 1
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
head = (0,0)
cnt = 0

from collections import deque
shifts = deque(shifts)
snake = deque([head])

while True :

    if shifts:
        if cnt == shifts[0][0]:
            sec, dir = shifts.popleft()
            if dir == 'L':
                D -= 1
                if D == -1 :
                    D = 3
            if dir == 'D':
                D += 1
                if D == 4 :
                    D = 0

    nx = head[0] + dx[D]
    ny = head[1] + dy[D]
    cnt += 1

    if nx < 0 or nx >= N or ny < 0 or ny >= N :
        break
    if snake.count((nx, ny)) :
        break

    snake.appendleft((nx, ny))

    if board[nx][ny] == 0 :
        snake.pop()
    if board[nx][ny] == 1 :
        board[nx][ny] = 0
    head = (nx, ny)

print(cnt)

• 일시 : 2021년 7월 4일
• 플랫폼 : 프로그래머스
• 총 문제 : 3문제
• 응시 언어 : python

연습용으로 보았고, AI application engineer 직군을 지원했다. 이후에 과제 테스트도 있다.

문제 1 번

solved

• 분류 : 반복문, 배열

lottery = [[1,0],[35,0],[1,0],[100,1],[35,1],[100,1],[35,0],[1,1],[1,1]]

def solution(lottery):
    record = {}
    for user in lottery:
        if record.get(user[0]) is None:
            record[user[0]] = [1, user[1]]
            continue
        value = record.get(user[0])
        if value[1] == 0 :
            value[0] += 1
            value[1] = user[1]
            record[user[0]] = value
    answer = [0,0]

    for user, result in record.items():
        if result[1] :
            answer[0] += result[0]
            answer[1] += 1
    return answer[0]//answer[1] if answer[1] > 0 else 0


print(solution(lottery))

문제 2번

solved

• 분류 : BFS

from collections import deque
import math
row, col = (len(grid), len(grid[0]))
path = [[math.inf]*col for _ in range(row)]
que = deque([(0,0,0)])
dx = [0,1]
dy = [1,0]

while que:
    node = que.popleft()
    x , y = node[:2]
    path[x][y] = min(path[x][y], grid[x][y] + node[-1])

    for i in range(2):
        nx = x + dx[i]
        ny = y + dy[i]

        if 0 <= nx < row and 0 <= ny < col :
            que.append((nx,ny,path[x][y]))

print(path[row-1][col-1])

문제 3번

• 분류 : DFS unsolved 시험 끝나고 나서 마저 풀었다.ㅠ

  from copy import  deepcopy
  import math
  

arr = [5,4,3,2,1] k = 4 limit = len(arr) pos = [-1] * (len(arr)+1) for i in range(len(arr)): pos[arr[i]] = i

cnt = 0 answer = math.inf

def DFS(max, arr , cnt,ordered):

if ordered == limit:
    global answer
    answer = min(answer, cnt)
    return

if max == arr.index(max)+1:
    DFS(max-1, arr, cnt,ordered+1)
    return

for i in range(1, k+1):

    index = arr.index(max)

    if index+i < limit - ordered:
        new_arr = deepcopy(arr)
        new_arr[index], new_arr[index + i] = new_arr[index + i], new_arr[index]
        DFS(max, new_arr, cnt + 1, ordered)

DFS(max(arr), arr, 0, 0) print(answer)

```

결론: 구현, DFS 문제를 더 풀어보자.

• HTTP http 프로토콜은 비연결성 이기 때문에 클라이언트와의 연결은 일회성이며 이후에 계속 유지되지 않는다. 따라서 서버 입장에서는 매번 새로운 클라이언트라고 인식한다. 클라이언트측에서 매번 자신이 누구인지에 대한 정보를 서버에게 보내야 하는 번거로움이 존재한다. stateless

• 클라이언트를 구분

쿠키

세션

보안 문제

• Browse

  verb. to look at or through something to see what is there

무엇이 있는지 보는 것, 또는 무언가를 통해 보는 것. Browse + er (웹 페이지를) 볼 수 있게 해주는 것.

• *브라우저란? *

  A web browser (commonly referred to as a browser) is a software application for accessing the World Wide Web. When a user requests a web page from a particular website, the web browser retrieves the necessary content from a web server and then displays the page on the user's device.

정확히는 웹 브라우저라고 부르는게 맞다. 웹 브라우저는 웹에 접근할 수 있는 소프트웨어이다.

• 브라우저의 역할

  The purpose of a web browser is to fetch content from the Web and display it on a user's device.

사용자가 특정 웹페이지를 요청하면 웹 브라우저는 웹 서버로부터 웹 페이지를 불러오고 유저의 화면에 보여준다.

• 정리 브라우저는 다른 컴퓨터(서버)에 있는 웹페이지를 요청하여 가져오고 사용자에게 보여주는 프로그램이다. 가져오는 것은 웹페이지 즉 html 파일이다. 주소창에 URL을 입력하면 웹서버가 주는 웹페이지(html)을 가져와서 사용자의 화면에 보여준다. 다른 서버에 있는 웹페이지를 가져오는 다른 방법도 있다. curl로 웹페이지를 가져온 경우 텍스트형식의 html문서를 가져온 것을 볼 수 있다. 브라우저는 이를 예쁘게 파싱해서 시각적으로 렌더링해서 보여준다는 차이점이 있다. 브라우저가 받게 되는 html은 동일하다. html은 하나의 긴 텍스트 문서라고 생각하면, 내가 특정한 글로된 정보를 보고 싶은데 그 정보는 어딘가 내가 모르는 다른 컴퓨터 내에 저장되어 있음. 브라우저는 나 대신해서 다른 컴퓨터의 위치를 찾아서 그 정보를 달라고 요청하고 정보를 받아와서 내가 잘 볼 수 있게 변환해서 보여준다.

브라우저의 구성

• 브라우저 구성 요소 출처: https://d2.naver.com/helloworld/59361

1. 사용자 인터페이스
   • 주소 표시줄, 이전/다음 버튼, 북마크 메뉴 등. 요청한 페이지를 보여주는 창을 제외한 나머지 모든 부분이다.
2. 브라우저 엔진
   • 사용자 인터페이스와 렌더링 엔진 사이의 동작을 제어.
3. 렌더링 엔진
   • 요청한 콘텐츠를 표시. 예를 들어 HTML을 요청하면 HTML과 CSS를 파싱하여 화면에 표시함.
4. 통신
   • HTTP 요청과 같은 네트워크 호출에 사용됨. 이것은 플랫폼 독립적인 인터페이스이고 각 플랫폼 하부에서 실행됨.
5. UI 백엔드
   • 콤보 박스와 창 같은 기본적인 장치를 그림. 플랫폼에서 명시하지 않은 일반적인 인터페이스로서, OS 사용자 인터페이스 체계를 사용.
6. 자바스크립트 해석기
   • 자바스크립트 코드를 해석하고 실행.
7. 자료 저장소
   • 이 부분은 자료를 저장하는 계층이다. 쿠키를 저장하는 것과 같이 모든 종류의 자원을 하드 디스크에 저장할 필요가 있다. HTML5 명세에는 브라우저가 지원하는 '웹 데이터 베이스'가 정의되어 있다.

브라우저의 동작 방식

• 렌더링 엔진

  • 요청한 웹서버가 html을 body에 담아서 돌려줌.
  • 이때 이 html파일은 완전 텍스트로만 이루어져 있음.
  • 텍스트 내의 태그들을 해석하여 특정한 구조를 만든다.
  • 시각적으로 렌더링하여 사용자의 화면에 보여준다.

• 동작 순서

1. HTML파일 파싱. Parsing html 형식으로 된 텍스트들을 구문 분석한다.

2. DOM 트리 구축

   • DOM : document object model. html 문서를 객체 형태의 모델로 변환한 것. 문서 객체 모델. 모든 태그들을 객체로. 구분 분석 후 각 요소들을 트리형태로 구성한다. 컨텐트(내용)를 구조화 한다.

3. 렌더 트리 구축 CSS/style 요소들을 파싱하여 트리형태로 구성한다. 내용을 어떻게 보여줄지(시각적)를 구조화한다.

4. 렌더 트리 배치 어떤 공간에 위치할지를 정한다. 레이아웃.

5. 렌더 트리 그리기 UI 백엔드가 각 노드들을 그린다.

브라우저의 통신

• HTTP/ HTTPS
  • HTTP : 좀 특별한 문서를 주고 받기 위한 통신 약속
  • HTTPS : 통신에 들어가는 데이터들이 암호화됨.
• DNS
  • 문자로 된 주소를 숫자로 이루어진 주소로 바꾸기 위해 찾는 작업. DNS 서버에 물어본다.