세상 어디에도 없는 친절한 개발자되기 프로젝트

[Go] 1. Hello world

Algorithm90 — Mon, 14 Oct 2019 21:45:47 +0900

package main

import "fmt"

func main() {
	fmt.Println("Hello 월드")
}

1. package main

main이라는 이름을 가지는 package를 선언한다.

일반적으로 패키지는 라이브러리로서 사용되지만, "main" 이라고 명명된 패키지는 Go 컴파일러에 의해 특별하게 인식된다.

패키지명이 main 인 경우, 컴파일러는 해당 패키지를 공유 라이브러리가 아닌 실행(executable) 프로그램으로 만든다.

2. import "fmt"

선언한 패키지 내에 "fmt"라는 표준 패키지를 포함시킨다.

여러 패키지를 import 하는 경우 아래와 같은 형태로 작성할 수 있다.

import (
    "a"
    "b"
    "c"
)

3. func main(){}

패키지 이름으로서의 main이 프로그램의 시작 패키지임을 나타낸다면

main 패키지 내의 함수 이름으로서의 main은 패키지 내의 시작점을 의미한다.

중괄호 안에 프로그램의 내용이 들어간다.

4. fmt.Println("hello 월드")

fmt 패키지 안에 있는 Println 함수를 호출한다.

[운영체제] 페이징(Paging)

Algorithm90 — Mon, 23 Sep 2019 15:04:58 +0900

1. 페이징이 필요한 이유

1) 메모리 단편화

메인 메모리에 여러 프로세스를 연속적으로 할당한 후에 몇몇 프로세스를 종료하게 되면 프로세스들이 종료된

자리 앞 뒤로는 다른 프로세스가 여전히 올라가 있고 종료된 자리만 비게 된다(Hole).

이 빈자리들이 다양한 크기로 여러 개 생기게 될 경우 빈자리들의 총합이 다음에 올라갈 프로세스보다 큼에도

불구하고 맞는 자리가 없어서 프로세스가 올라오지 못하는 현상이 발생하게 되는 것을 외부 단편화라고 한다.

(external fragmentation)

단편화가 발생할 경우 메모리를 효율적으로 사용할 수 없게 된다.(일반적으로 1/3 정도를 못쓰게 된다고 함.)

2. 페이징

1) 프로세스를 일정 크기로 쪼갠 것을 page라고 하고 메모리를 일정 크기(page의 크기와 같음)로 쪼갠 것을

frame이라고 한다.

2) cpu가 알고 있는 logical address를 page table(MMU)에 매칭 시켜 실제 메모리에는 logical address와는

다른 주소(physical address)에 할당한다.

(page를 frame에 할당)

3) page를 연속적으로 가지고 있는 가상 메모리와 page table을 이용하면, 실제로 메모리 상에 프로세스가

쪼개져서 존재하더라도 프로세스를 실행시킬 수 있게 된다.

4) 실제 메모리 상에 프로세스가 연속적이지 않고, 더 작은 크기로 존재할 수 있게 되므로 메모리 단편화

문제를 해결할 수 있다.

[운영체제] 메모리 관리

Algorithm90 — Fri, 20 Sep 2019 21:21:41 +0900

1. 메모리 구조

- 주소(Address) + 데이터(Data)

2. 프로그램 개발단계의 파일 종류

- 원천파일(Source file) : 고수준 언어 또는 어셈블리언어로 작성된 파일

(컴파일러, 어셈블러)

- 목적파일(Object file) : 컴파일 또는 어셈블 결과

(링커 )

- 실행파일(Executable file) : 링크(라이브러리와 목적파일의 연결) 결과

(실행파일을 로더를 통해 메인메모리에 올림)

3. 프로그램 실행단계의 메모리 영역

- code(기계어로 된 로직이 있는 영역) + data(연산을 위한 데이터가 있는 영역) + stack(지역변수, 돌아올 지점 저장)

4. MMU(Memory Management Unit)

- base register

- limit register

- relocation register

cpu가 지정한 주소(logical address)에 mmu가 숫자를 더해서 만든 주소(physical address)에 할당(address translation)

-> 실행파일이 어떤 번지에 있더라도 상관없게 해준다.

5. 메모리 낭비 방지

1) Dynamic Loading(동적 적재)

- 프로그램 실행에 반드시 필요한 루틴 / 데이터만 적재한다.

ex) 소스코드에 쓰여진 오류처리 루틴은 오류가 발생할 때만 필요하므로 오류가 발생할 때 메모리에 로드하는게 경제적임

2) Dynamic Linking(동적 연결)

- 공통 라이브러리 루틴이 메모리에 중복으로 올라오는 것은 메모리 낭비를 초래하므로 실행파일을 만들면서 연결을 하지 않고 하나의 라이브러리 루틴만 메모리에 올려놓은 상태로 어플리케이션 실행 시 루틴과 연결하게 한다.

(리눅스에서는 shared library, 윈도우에서는 Dynamic Linking Library 이라고 부름)

3) Swapping

- swap out

메모리에 적재되어 있으나 현재 사용되지 않고 있는 프로세스 이미지를 사용 중이던 상태로 하드디스크의

특정부분(backing store) 으로 내린다. (이미 존재하던 .exe 파일과는 구분된다.)

- swap in

swap out 된 이미지를 다시 메인메모리로 올린다.(프로세스의 크기가 클수록 하드디스크에 써야하는 크기가 커져서

입출력에 따른 부담이 있음.)

[운영체제] 교착상태(Deadlock)

Algorithm90 — Thu, 19 Sep 2019 16:19:04 +0900

1. 교착상태의 필요 조건

아래 네가지 조건이 모두 충족 된다면 교착상태가 일어날 수 있다.

1) Mutual exclusion(상호배타)
어떤 자원을 한 프로세스가 사용하고 있다면 다른 프로세스가 사용할 수 없는 상태

(한 철학자가 젓가락을 들었다면 그 젓가락은 다른 철학자가 사용할 수 없음)

2) Hold and wait(보유 및 대기)

한 자원을 보유하고 있는 상태로 나머지 자원이 충족되기를 기다리고 있는 상태

(각 철학자가 모두 왼쪽 젓가락을 든 채로 오른쪽 젓가락을 기다리고 있음)

3) No Preemption(비선점)

다른 프로세스가 사용 중인 자원을 강제로 뺏을 수 없는 상태

(다른 철학자가 들고 있는 젓가락을 강제로 가져올 수 없음)

4) Circular wait(환형대기)

자원과 자원을 사용하려는 프로세스들이 원형으로 물려있는 상태

(각 철학자의 오른쪽 젓가락이 왼쪽 철학자의 왼쪽 젓가락임)

2. 교착상태 방지(Deadlock Prevention)

교착상태는 위의 네가지 조건을 모두 만족해야 일어날 수 있으므로 한가지 이상의 조건을

불만족 시킴으로써 교착상태를 방지할 수 있다.

1) 상호배타

자원을 공유 가능하게 만들면 해결할 수 있지만, 원천적으로 자원 공유가 불가능한 경우가 많음

(cpu를 스위칭하면서 쓸수는 있어도 동시에는 사용불가)

2) 보유 및 대기

한 쪽을 보유 한 뒤 나머지를 대기하는 방식의 알고리즘 대신, 두 자원을 동시에 보유할 수 있는 상태에서만

자원을 가져갈 수 있게 변경, 또는 나머지 자원을 즉시 가져갈 수 없다면 보유하고 있는 자원도 놓게 변경해서 해결 가능.

3) 비선점

다른 프로세스가 사용하고 있는 자원을 강제로 뺏어올 수 있게 변경한다면 발생할 수 있는 문제가 많아 불가능

(다른 프로세스가 사용중인 프린터를 강제로 뺏어온다면 인쇄에 제대로 되지 않음)

4) 환형대기

자원에 번호를 부여하고, 자원을 요청할 때 오름차순으로 자원을 요청하는 알고리즘을 적용해서 해결 가능

(마지막을 제외한 철학자들이 모두 왼쪽, 오른쪽의 순서로 젓가락을 요청하게 되고 마지막 철학자는 오른쪽, 왼쪽의 순서로

젓가락을 요청하게 되서 원이 만들어지지 않음)

3. 교착상태 회피(Deadlock Avoidance)

교착상태를 자원 요청에 대한 잘못된 승인이라고 해석

운영체제는 자원을 할당할 때, 선 할당 후 남은 자원으로 프로세스의 작업을 끝내지 못하는 상태(불완전 할당)를

만들지 않도록 해야한다.(Banker's algorithm)

4. 교착상태 검출 및 복구(Deadlock Detection & Recovery)

프로세스가 요청하는대로 자원을 모두 나누어 주고 일정시간 마다 O/S가 교착상태를 검사하여 교착상태가 발견됐다면

프로세스를 일부 강제종료 시키거나, 자원을 빼앗아 다른 프로세스에게 할당하여 해결하는 방식.

복구를 위한 이전 상태 기억과, 교착상태 검사로 인한 오버헤드가 발생하는 문제점이 있음.

5. 교착상태 무시

개인 pc에서는 교착상태가 잘 일어나지 않으므로 무시하는 방식.

[네트워크] OSI 모델의 계층별 역할

Algorithm90 — Mon, 16 Sep 2019 20:12:49 +0900

1. 물리 계층(physical layer)

1) 데이터가 네트워크 인터페이스를 통해 물리적으로 전송되는 유일한 계층.

2) 케이블, 커넥터, 네트워크 인터페이스 카드 등 하드웨어 장비 동작의 세부사항을 정의한다.

3) 컴퓨터나 기타 장비에 존재하는 0과 1로 된 비트 데이터를 네트워크를 통해 전송하기 위한 신호로 변환하여

송신하고 수신한 네트워크 신호를 비트 데이터로 변환하여 데이터 링크 계층에 전달한다.

2. 데이터 링크 계층(data link layer)

1) 네트워크의 로컬 장비 간 논리적 연결을 수립하고 제어하는 역할을 한다.(Local Link Control)

2) 상위에 있는 네트워크 계층에게 필요한 서비스를 제공하며, 데이터 링크 계층의 세부적인 정보를 감춰

서로 다른 기술이 상위 계층과 쉽게 결합될 수 있도록 한다.

3) 공유매체를 이용하면서 발생할 수 있는 충돌을 피하기 위한 관리를 한다. (Media Access Control)

4) 데이터를 특정 머신으로만 보낼 수 있도록 하는데 쓰이는 MAC 주소를 지정한다.

3. 네트워크 계층(network layer)

1) 원격 네트워크에 있는 컴퓨터에게 데이터를 전송할 수 있는 기능과 관련된 가자아 낮은 계층.

2) 통신할 장비의 논리적 주소를 지정한다.(인터넷의 경우 IP주소)

3) 여러 곳에서 들어오는 패킷을 받아 최종 목적지를 파악하고 패킷이 통과해야 할 다음 경로를 결정한다.

4) 송신을 위한 데이터의 크기가 데이터링크 계층에서 요구하는 크기보다 클 경우 데이터를 단편화하고,

단편화된 데이터를 수신하여 재조합한다.

5) 개별 네트워크를 인터네트워크로 연결한다.

4. 전송 계층(transfer layer)

1) 서로 다른 컴퓨터에 있는 소프트웨어 애플리케이션 프로세스들이 서로 통신하는데 필요한 기능을 제공.

2) 송신의 경우 각 애플리케이션에서 나오는 데이터를 추적하여 하나의 데이터 흐름으로 결합하고 하위 계층으로

내려보낸다.

3) 수신의 경우 데이터를 분리하여 적절한 프로세스에 전달한다.

4) 여러 소프트웨어 프로그램이 동시에 네트워크 계층 프로토콜을 이용할 수 있도록 프로세스 수준의 주소를 지정한다.

(ex. TCP / UDP 포트를 이용)

5) 연결을 수립하고 유지하고 종료하는데 필요한 통신과정을 관리한다.

5. 세션 계층(session layer)

1) 두 소프트웨어 애플리케이션 간의 지속적인 논리적 연결로 데이터를 교환할 수 있도록 한다.

2) 세션 계층 기술은 API라는 소프트웨어 도구 모음으로 제공되기도 하는데, API는 프로그래머가 전송, 주소지정, 전달 과 관련된 하위 수준 세부 사항에 신경쓰지 않고 애플리케이션을 개발할 수 있도록 해준다.

6. 프리젠테이션 계층(presentation layer)

1) 한 계층에서 송신한 데이터를 수신 시스템에서 달느 방법으로 볼 필요가 있을 때 발생하는 문제를 처리한다.

ex) 번역, 압축, 암호화 등

2) 프리젠테이션 계층에서 일어나는 일들이 네트워크 통신에서 항상 필요한 것은 아니기 때문에 제외되는 경우가 많다.

7. 애플리케이션 계층(application layer)

1) 사용자 애플리케이션이 이용할 수 있는 서비스를 제공한다.

ex) 브라우저에 HTTP 의 서비스를 제공

[네트워크] OSI 모델 기본개념 정리

Algorithm90 — Thu, 5 Sep 2019 12:26:45 +0900

1. OSI 계층에서의 인터페이스

인접한 계층(N+1 혹은 N-1층) 간의 통신 방식.

OSI 참조 모델은 다양한 계층의 구현 간 상호작용을 가능케 한다는목적을 지니므로

계층을 서로 잘 연결하기위해 일관되고 문서화된 인터페이스가 필요하다.

또한 인터페이스가 존재함으로써 상위 계층은 하위 계층의 세부 구현에 대한 지식 없이도

여러 하위 계층 서비스를 이용할 수 있게 된다.

2. OSI 계층에서의 프로토콜

네트워크 장비의 동일 계층에서 운영 중인 소프트웨어나 하드웨어 간의 통신을 정의하는 규칙이나 절차 모음을 가리킨다.

각 장비에 있는 동일한 계층은 1계층에서만 물리적으로 연결되어 있는 상태로 논리적인 통신을 한다.(수평적 통신)

3. 포워딩과 라우팅

인터네트워크(네트워크의 네트워크)가 존재할 때 한 네트워크에 있는 메시지를 다른 네트워크로 보내는 과정을 포워딩이라고 하며,

한 장비에서 다른 장비로 포워딩하는 종합적인 과정을 라우팅이라고 한다.

(통합해서 라우팅이라고 사용하기도 함)

4. 메시지 라우팅 과정

상위 수준 애플리케이션에서 원격지 컴퓨터에 데이터그램을 보내고자 할 때

1) 데이터그램이 패키징되어 프로토콜 스택의 아래 방향으로 전달된다. (이 과정에서 각 계층은 데이터를 캡슐화 함)

2) 데이터그램의 목적지 주소는 최종 목적지 장비의 주소로 설정되어 있지만, 하위 계층으로 전달되는 메시지는 최종 목적지가 아닌 중간 장비(데이터를 다음 목적지까지 라우팅할 책임이 있는)로 전달되도록 패키징된다.

3) 중간장비는 물리계층에서 메시지를 받아 데이터링크 계층으로 전달하며, 에러 검사 등을 한 뒤 헤더를 제거한 데이터를

네트워크 계층으로 전달한다.

4) 네트워크 계층에서 해당 메시지의 최종 목적지가 같은 네트워크 안에 있는 지, 포워딩 해야 하는지를 확인하고,

다시 패키징해서 하위 계층으로 메시지를 내려보낸다.

5) 포워딩이 더 필요하다면 위 과정이 반복되고, 목적지에 있는 장비에 메시지가 도착하게 되면 송신한 계층에 맞는 상위 계층까지

전달된다.

TCP/IP 완벽 가이드 / charles M.Kozierok 을 보고 정리한 내용입니다.

[네트워크] 연결형 프로토콜, 비연결형 프로토콜

Algorithm90 — Tue, 3 Sep 2019 18:09:00 +0900

1. 연결형 프로토콜

두 장비가 데이터를 전송하기 전에 논리적 연결을 맺는 프로토콜

이를 위해 장비들은 연결을 어떻게 시작하고, 협상하고, 관리하고, 끊는지를 명시하는 규칙을 따른다.

일반적으로 한 장비가 먼저 연결 맺기를 요청하면 다른 한쪽이 응답하고, 연결을 맺을지, 맺는다면 어떻게 맺을지에 대한

제어 정보를 주고 받는다.

2. 비연결형 프로토콜

장비간에 연결을 맺지 않는 프로토콜.

데이터를 보내고 싶은 장비는 즉시 데이터를 보낸다.

3. 네트워크 메시지 포메팅

메시지들의 공통적인 특성은 전송될 데이터 페이로드를 헤더와 푸터가 감싸고 있는 형태로 구성되어 있다는 점이다.

네트워킹 프로토콜에서 송신된 모든 메시지 데이터는 상위 계층에서 캡슐화된 헤더, 데이터, 푸터를 담고있으며,

이러한 중첩은 하위 계층으로 내려오면서 여러번 일어날 수 있다.

헤더

메시지가 담고 있는 데이터의 중요한 속성, 데이터를 해석하고 사용하는 법을 설명하는 여러 작은 제어 정보 바이트를 포함한다.

서로 다른 장비의 프로토콜 요소간 통신/제어 링크 역할을 한다.

데이터

전송되는 실제 데이터.

데이터를 전송하기 전에 논리적 연결을 맺거나, 연결을 끊는 경우에 쓰이는 메시지는 데이터를 담고 있지 않는다.

푸터

데이터 뒤에 위치하며 헤더와 같은 통신/제어 링크 역할을 한다.

전송중인 데이터를 계산에 이용한 값을 저장하기 위해 쓰인다.

4. 메시지 전송 방법

1) 유니캐스트 메시지

한 장비에서 다른 한 장비로 전송하는 메시지이다.

지정된 수신자가 아닌 장비는 메시지를 받으면 안된다.

2) 브로드캐스트 메시지

한 장비에서 네트워크에 연결된 모든 장비로 보내는 메시지이다.

3) 멀티 캐스트 메시지

특정 기준을 만족하는 스테이션 그룹으로 보내지는 메시지이다.

TCP/IP 완벽 가이드 / charles M.Kozierok 을 보고 정리한 내용입니다.

[알고리즘] 스택에서 O(1) 안에 최소값 찾기

Algorithm90 — Tue, 27 Aug 2019 11:37:15 +0900

# 스택에서 min함수를 통해 O(1)로 최소값 찾기


class Stack:
    def __init__(self):
        self.container = list()

        # 최소값을 담아두기 위한 컨테이너
        self.min_container = list()

    def push(self, data):
        self.container.append(data)

        # 최소값 갱신
        if not self.min_container or data < self.min_container[-1]:
            self.min_container.append(data)

    def pop(self):
        pop_data = self.container.pop()

        # 삭제되는 데이터가 최소값이라면 최소값을 갱신
        if pop_data == self.min_container[-1]:
            self.min_container.pop()
		
        return pop_data
        
    def _min(self):
        if not self.min_container:
            return None

        return self.min_container[-1]

[알고리즘] 연결리스트 안에서 중복 없애기, 뒤에서 k번째 요소 찾기

Algorithm90 — Mon, 26 Aug 2019 14:26:35 +0900

1. 정렬되어 있지 않은 연결리스트에서 중복되는 원소를 제거하기

# 연결리스트를 순회하면서 딕셔너리에 Node의 data를 담아두고
# data 값의 key가 존재하면 노드를 삭제
def remove_duplication1(node):
    compare_table = {}
    previous = None

    while node:
        if node.data in compare_table:
            previous.next = node.next
        else:
            compare_table[node.data] = 1

        previous = node
        node = node.next

# 다른 자료구조를 사용할 수 없는 경우 연결리스트 내에서 두개의 포인터를 사용해서
# 중복되는 원소가 있는지 확인
def remove_duplication2(head):
    cur = head

    while cur:
        runner = cur

        while runner.next:
            if cur.data == runner.next.data:
            	# 중복되는 데이터가 발견된다면
                # 이전 노드의 next에 다음 노드를 연결
                runner.next = runner.next.next
            else:
            	# 중복값이 아니라면 runner를 다음 노드로 이동
                runner = runner.next

        cur = cur.next

2. 뒤에서 k번째 요소 찾기

# 재귀적 방법
def find_element_recursive(k, node):
    if not node:
        return [0, None]

    # 연결리스트의 끝까지 이동
    count_and_element = find_element_recursive(k, node.next)

    # 뒤에서 몇번째인지 카운트
    count_and_element[0] += 1

    # 찾고자 하는 원소라면 데이터의 값을 할당
    if count_and_element[0] == k:
        count_and_element[1] = node.data
        return count_and_element

    # 찾고자 하는 원소가 아니라면 카운트만 반영한 뒤 리턴
    else:
        return count_and_element

# 순환적 방법
# 두개의 포인터를 두고 그 중 하나를 k만큼 미리 이동시켜 놓는다면
# 이동시킨 포인터가 연결리스트의 끝에 도착했을 때 나머지 카운터가 끝에서 k번째 위치에 도달하게 된다.
def find_element_iterative(k, head):
    find_element = head
    find_end = head

    for _ in range(k):
        if not find_end:
            return None
        find_end = find_end.next

    while find_end.next:
        find_element = find_element.next
        find_end = find_end.next

    return find_element.data

Cracking the Coding Interview (Gayle Laakmann McDowell) 의 예제를 파이썬 코드로 작성해 보았습니다.

[알고리즘] 문자열 비교

Algorithm90 — Sun, 25 Aug 2019 17:25:54 +0900

두가지 경우에서 중복되는 부분을 합쳐 한번에 계산하는 방식

수정 후(답안지)

def one_edit_away(first, second):
    # 길이 체크
    if abs(len(first) - len(second)) > 1:
        return False

    # 길이가 다른 문자열 구분
    if len(first) > len(second):
        first, second = second, first

    index_first = 0
    index_second = 0

    found_difference = False

    while index_second < len(second) and index_first < len(first):
        if first[index_first] != second[index_second]:
            if found_difference:
                return False
            found_difference = True
            
            # 교체하는 경우 짧은 문자열의 포인터를 증가
            if len(first) == len(second):
                index_first += 1
        
        # 동일하다면 짧은 문자열의 포인터를 증가
        else:
            index_first += 1
        
        # 긴 문자열의 포인터는 언제나 증가
        index_second += 1

    return True

수정 전(풀이)

# 두 개의 문자열을 최대 한 번만 수정했을 때 같아질 수 있는지 확인하는 함수를 만드세요.

string1 = "aabb"
string2 = "abbb"


def compare_strings(a, b):
    length_a = len(a)
    length_b = len(b)

    inconsistancy_count = 0

    # 두 문자열의 길이가 같을 경우 각 자리에 있는 문자를 비교하면서 수정횟수가 1을 초과하는지 확인
    if length_a == length_b:
        for i in range(length_a):
            if a[i] == b[i]:
                continue
            else:
                inconsistancy_count += 1
                if inconsistancy_count > 1:
                    return False

    # 문자열 길이의 차이가 1이라면 다른 부분을 찾아 고치거나, 삭제하고 같은지 확인
    elif abs(length_a - length_b) == 1:
        index_a = 0
        index_b = 0

        # 짧은 문자열과 긴 문자열을 항상 같은 위치에서 비교할 수 있게 구분
        if length_a > length_b:
            a, b = b, a
            length_a, length_b = length_b, length_a

        while index_a < length_a and index_b < length_b:
            # 각 문자가 같다면 둘 다 인덱스를 이동시킴
            if a[index_a] == b[index_b]:
                index_a += 1
                index_b += 1
            # 같지 않다면 불일치 카운터를 올리고 긴 문자열의 인덱스만 이동시킴
            else:
                inconsistancy_count += 1
                if inconsistancy_count > 1:
                    return False
                index_b += 1

    else:
        return False

    return True