세네카가 루실리우스에게 쓴 편지에는 이러한 빈곤을 미리 예행 연습해 봄으로써 오히려 더 큰 자유를 얻을 수 있다고 한다.

이번에 내가 읽은 타이탄의 도구들에서 제시하는 방법은 아래와 같다

• 거실 바닥이나 야외에서, 침낭에서 잠자기
• 3~14일 동안 싸구려 흰색 셔트와 청바지 한 벌 입기
• 카우치 서핑 이용하기
• 즉석 통조림이나 쌀과 콩만 먹기
• 나뭇가지나 종이, 나뭇잎만을 연료로 요리하기
• 최대한 단식하기
• 인터넷 검색은 도서관만 이용하기

이건 현실적으로 사회생활을 영위하는 직장인인 나에게 조금은 어려워 보인다. 그래서 이 실험을 조금 변형해서 내가 장기적으로 건강한 삶을 유지하기 위한 최소 비용은 얼마일지 측정하는 실험으로 바꾸고 최소 비용으로 살아가면서 나의 감정을 기록해보기로 한다.

트리를 표현하기 위해 배열을 사용하면 실제 트리에서 비어있는 부분도 전부 인덱스로 설정함 쓰지 않는 인덱스들은 결국 빈값이 되기 때문에 메모리가 낭비되지만 구현이 쉽기 때문에 배열로 이진트리를 구현해도 괜찮음

참고로 이렇게 되면 이진트리 노드가 N이라면 배열로 생성하면 그 시간복잡도는 O(N)

이진트리 순회하기

순회 = 빠짐없이 노드들의 데이터를 방문하는 것

아래에 대표적인 3가지 방식의 순회 방법을 소개하는데

이때 중요한 것은 현재 노드를 부모노드로 생각했을 때!!

전위순회 Preorder

부모 ->왼쪽자식 -> 오른쪽 자식

직관적으로 가장 이해하기 쉬운 순회 방식으로 트리를 복사할 때에 많이 사용함

중위순회 Inorder

왼쪽자식 -> 부모 -> 오늘쪽 자식

현재 노드를 거치기만 할 뿐 방문하지는 않음!

후위순회 Postorder

왼쪽자식 -> 오른쪽 자식 -> 부모

노드를 삭제할 때 부모 먼저 삭제할 수 없기 때문에 트리를 삭제할때 후위 순회가 주로 사용됨

Pointer로 표현하기

하나의 노드를 구현할 때 서로의 관계를 표현함 그러니까 노드가 노드의 값 + 왼쪽 자식노드 + 오른쪽 자식노드 로 표현됨 그렇기 때문에 메모리 공간을 낭비하진 않지만 노드를 하나하나 따라가도록 구현해야하기 때문에 구현 난이도가 높음

여기까지 기초라고 하면 이진 트리에서 가장 중요한 것은 탐색이 효율적이어야 한다는 것 그러니까 여기저기 왓다갓다 값찾는게 효율적이도록 트리를 구축하는 것이 가장 중요함!!

이진 탐색 트리

binary search tree라고 하고 이를 활용해 원하는 노드를 효율적으로 찾아보자

예를 들어 트리의 데이터가 아래의 순서대로 들어온다 3 -> 4 -> 2 -> 8 -> 9 -> 7 -> 1 이진 탐색트리는 데이터 크기가 작으면 왼쪽 자식 크거나 같으면 오른쪽 자식 위치에 배치한다

이게 무슨말이냐면 오른쪽 자식들은 나를 기준으로 전부 다 크거나 같고 왼쪽 자식들은 나를 기준으로 전부 다 작다 (대대손손!)

이런 식으로!

규칙이 있으니까 이 규칙을 기반으로 탐색하면 됨 이미지에서 처럼 내가 찾으려는 값이 13이라면 찾으려는 값이 현재노드보다 크면 오른쪽 작으면 왼쪽 이렇게 움직인다

이런 방식이 검색을 빠르게 만들어 줌

예를 들어 위의 이진트리에서 배열 방식이었다면? [3, 4, 6, 9, 12, 13, 15, 17] 여기서 13을 찾기위해 6번의 비교연산을 수행해야함! (13의 배열 위치까지!) 하지만 트리 기반으로 탐색하면 4번의 비교연산으로 13을 찾아낼 수 있음

그럼 당연히 이 시간 복잡도는 트리가 얼마나 균형잡히게 생겼는지에 의존함 잘 균형이 잡혀있다면 삽입과 탐색 연산시 저장된 노드가 N개라고 할 때 시간복잡도는 O(logN) 임!!

하지만 완저니 치우쳐저 있다면? 당연히 배열이랑 똑같은 O(N)임! 이런 치우쳐진 형태를 degenerate binary tree라고 표현함

균형 이진 탐색 트리 balanced binary search tree

세부적으로는 AVL 트리, 레드-블랙 트리 이렇게 구분하기도 하는데 사실 완전히 균형적인 이진 탐색 트리는 구현 난이도가 높아서 더 공부하고 싶으면 따로 깊게 파야함

문제 26. 트리 순회

## question 26
def preorder(nodes, idx=0):
    if idx < len(nodes):
        traj = str(nodes[idx]) + " "
        traj += preorder(nodes, idx * 2 + 1)
        traj += preorder(nodes, idx * 2 + 2)
        return traj
    else:
        return ""

def inorder(nodes, idx=0):
    if idx < len(nodes):
        traj = inorder(nodes, 2 * idx + 1)
        traj += str(nodes[idx]) + " "
        traj += inorder(nodes, 2 * idx + 2)
        return traj
    else:
        return ""

def postorder(nodes, idx=0):
    if idx < len(nodes):
        traj = postorder(nodes, 2 * idx + 1)
        traj += postorder(nodes, 2 * idx + 2)
        traj += str(nodes[idx]) + " "
        return traj
    else:
        return ""

def solution(nodes):
    return [preorder(nodes)[:-1], inorder(nodes)[:-1], postorder(nodes)[:-1]]

nodes = [1, 2, 3, 4, 5, 6, 7]
print(solution(nodes))

이거 거의 답지보고 했음;; 재귀가 들어가면 어쩔줄 몰라하는 나~~ 일단 시간 복잡도가 몇일까? 모든 노드를 방문하기 때문에 일단 O(N)

문제 27. 이진 탐색 트리 구현

pointer 방식으로 이진트리 구현.. 이것도 답지보고했음;;

## question 27
class Node:
    def __init__(self, key):
        self.left = None
        self.right = None
        self.val = key
class BinarySearchTree:
    def __init__(self):
        self.root = None

    def insert(self, key):
        if not self.root:
            self.root = Node(key)
        else:
            curr = self.root
            while True:
                if key < curr.val:
                    if curr.left:
                        curr = curr.left
                    else:
                        curr.left = Node(key)
                        break
                else:
                    if curr.right:
                        curr = curr.right
                    else:
                        curr.right = Node(key)
                        break

    def search(self, key):
        curr = self.root
        while curr and curr.val != key:
            if key < curr.val:
                curr = curr.left
            else:
                curr = curr.right
        return curr

def solution(lst, search_lst):
    bst = BinarySearchTree()
    for key in lst:
        bst.insert(key)

    result = []
    for key in search_lst:
        if bst.search(key):
            result.append(True)
        else:
            result.append(False)

    return result



lst = [5, 3, 8, 4, 2, 1, 7, 10]
lst_tree = [5, 3, 8, 2, 4, 7, 10, 1]
search_lst = [1, 2, 5, 6]

print(solution(lst, search_lst))

문제 28. 예상 대진표

하 돌겟네 트리!!

## question 28
def solution(N, A, B):
    answer = 0
    while A != B:
        A = (A + 1) // 2
        B = (B + 1) // 2
        answer += 1
    return answer
N = 8
A = 4
B = 7
answer = 3
solution(N, A, B)

문제 29. 다단계 칫솔 판매

내가 한 것 :

## question 29
from math import floor
def solution(enroll, referral, seller, amount):

    # 조직도와 수입 초기화
    organize = {}
    income = {}
    for i in range(len(enroll)):
        if enroll[i] in organize:
            organize[enroll[i]] = referral[i]
            income[enroll[i]] = 0

    for i in range(len(seller)):
        money = amount[i] * 100
        p = seller[i]
        while p != "-":
            income[p] += (money - floor(money * 0.1))
            money = floor(money * 0.1)
            p = organize[p]
    return list(income.values())

enroll = ["john", "mary", "edward", "sam", "emily", "jaimie", "tod", "young"]
referral = ["-", "-", "mary", "edward", "mary", "mary", "jaimie", "edward"]
seller = ["young", "john", "tod", "emily", "mary"]    
amount = [12, 4, 2, 5, 10]    
result = [360, 958, 108, 0, 450, 18, 180, 1080]
print(solution(enroll, referral, seller, amount))

내가 몰랐던 것 :

여기서 enroll이랑 referral이랑 짝지을때, 나는 for문으로 일일이 돌리면서 했는데 zip으로 묶어줄 수 있음! 그러니까

organize = dict(zip(enroll, referral))
income = {name : 0 for name in enroll}

이렇게 하면 훨씬 간단하게 할 수 있었음!!

비슷하게 마지막에도 list할때 순서 바뀔까봐 불안했는데,

[income[name] for name in enroll]

했으면 해결될 일!

너비 우선 탐색

start - end 까지의 경로를 찾는 문제는 대표적으로 BFS와 DFS를 많이 말한다 그리고 그 길에 가중치가 있다면 다익스트라 알고리즘이라는 것도 있음! 여기서 다음에 나올 예제가 미로탐색이라서 너비 우선 탐색에 대해 잠깐 짚고 넘어가고자 한다

너비 우선 탐색은 항상 최단 경로를 보장한다! 모든 가능한 길에 대해서 다 훑어보고 가장 먼저 끝나는걸 get하면 되기 때문!

쉽게 생각하면 너비우선은 10문제를 풀기위해 5초하고 다음문제 5초하고 다음문제 이런식이면 깊이 우선은 1문제 결과 나올때까지 풀고 다음문제 넘어가는 식!

문제 30. 미로 탈출

내가 풀이를 보고 이해한 바로는 가능한 병사들을 무한히 세팅해놓고 갈림길이 나올때마다 병사를 풀어서 그 병사들의 GPS를 추적하는 방식!

내가 답지를 본 후에 아이디어 이해하고 다시 짠 것 :

## question 30

from collections import deque

def solution(maps):
    q = deque()
    dx = [1, -1, 0, 0]
    dy = [0, 0, 1, -1]
    n = len(maps[0])# 가로
    m = len(maps)# 세로
    visited = [[[0] * 2 for _ in range(n)] for _ in range(m)]

    # start 파악하기
    find_start = False
    for i in range(n):
        if find_start:
            break
        for j in range(m):
            if maps[j][i] == 'S':
                start_x = i
                start_y = j
                q.append([start_x, start_y, 0, 0]) # x좌표, y좌표, lever작동여부, time
                visited[j][i][0] = 1
                find_start = True
                break

    # 경로 탐색하기
    while q:
        x, y, l, time = q.popleft()
        for k in range(4):
            new_x = x + dx[k]
            new_y = y + dy[k]
            if (0 <= new_x < n) and (0 <= new_y < m) and (visited[new_y][new_x][l] != 1):
                if (maps[new_y][new_x]=='E') and (l==1):
                    return time + 1
                elif maps[new_y][new_x] == 'O' or maps[new_y][new_x] == 'S':
                    q.append([new_x, new_y, l, time + 1])
                    visited[new_y][new_x][l] = 1
                elif maps[new_y][new_x] == 'L':
                    q.append([new_x, new_y, 1, time + 1])
                    visited[new_y][new_x][0] = 1
                    visited[new_y][new_x][1] = 1
                elif (maps[new_y][new_x]=='E') and (l==0):
                    q.append([new_x, new_y, l, time + 1])
                    visited[new_y][new_x][l] = 1                    

    return -1

문제 31.

문제 18. 두 개의 수로 특정값 만들기

내가 한 것 :

## question 18

def solution(arr, target):
    map = dict()
    for member in arr:
        map[member] = target - member

    for key, value in map.items():
        try:
            answer = map[value]
            print('answer is ', answer)
            if key == value:
                continue
            else:
                return 'True'
        except:
            continue
    return 'False'

arr = [1, 2, 3, 4, 8]
target = 6
print(solution(arr, target))

arr = [2, 3, 5, 9]
target = 10
print(solution(arr, target))

arr의 길이를 N, target의 크기를 K라고 할 때 내가 한 풀이의 시간복잡도는 O(N+N) 같은데.. (답지는 O(N+K)를 말하는데 내꺼가 더 낫지 않나? 우하하)

💡GPT의 조언

1) 나는 try-except구문을 잘 사용하는 편인데 이게 일단 추천하지 않음

: try-except구문에서 예외 상황이 발생하면, 내부적으로 stack-frame을 발생하고 예외객체를 생성하는 등 예외처리를 위한 다른 일을 진행함! 몰랐어!! 그렇기 때문에 진짜 예외처리를 위해서 사용하는 것이 좋음

2) map은 실제 python에 있는 내장함수이기 때문에 사용하는걸 추천하지 않음

: map은 python에서 iterable 객체에 함수를 취해주는 내장함수

list(map(round, [1.1, 2, 3.5]))

이런식으로..

※ (참고) map은 그럼 시간복잡도가 몇일까? 일단 map을 한다고 해서 다 계산하지 않음 그냥 next로 호출되면 계산될 뿐. 그래서 한번은 O(1)인데 이걸 전체의 list안에 있는 만큼 반복하면 O(N)이 됨

3) 그리고 미안하지만 네가 한 것에서 시간복잡도는 O(N)~O(N^2)란다 : 책에서 나온 것처럼 hash 함수에서 충돌이 생긴다면, 내가 제안한 map[value]는 시간복잡도가 O(1)이 아니라 최악의 경우(모든 key-value가 충돌하는 경우) O(N)이 될 수 있음 이 구문이 지금 for문 안에 있으니까 O(N^2)가 될 수 있음....(조금 억지같지만 맞말..)

그럼 gpt의 조언에 따라 코드를 바꾸면

## question 18

def solution(arr, target):
    arr_target = dict()
    for member in arr:
        arr_target[member] = target - member

    for key, value in arr_target.items():
        if (key != value) and value in arr_target:
                return 'True'
    return 'False'

arr = [1, 2, 3, 4, 8]
target = 6
print(solution(arr, target))

arr = [2, 3, 5, 9]
target = 10
print(solution(arr, target))

책에서 제안한 것 :

def count_sort(arr, k):
    ## hash table의 생성 및 초기화 ---!!!
    hashtable = [0] * (k+1)

    for num in arr:
        if num <= k:
            hashtable[num] = 1
    return hashtable

def solution(arr, target):
    hashtable = count_sort(arr, target)

    for num in arr:
        complement = target - num
        if (
            complement != num
            and complement >= 0
            and complement <= target
            and hashtable[complement] == 1
        ):
            return True
    return False

차이를 보면 일단 이건 hashtable을 직접 생성함 - 충돌이 있을 수가 없긴해;;

근데 충돌이 안생기면 처음 초기화 하면서 시간복잡도가 O(K)이고 for문 한번 돌면서 O(N)이고 solution에서의 for문 한번 더 돌면서 O(N)이니까 나보다 더 시간복잡도가 높을 수도 있을 것 같은데?

근데 time으로 테스트해보니까 큰 수로 했을 때, 내 코드(dictionary-based code)가 array-based code보다 느렸음. gpt가 분석했을 때, 이는 메모리 재할당 때문인것으로 추측됨. 나는 arr를 돌면서 하나하나 key-value로 dictionary에 추가하는데 arr가 과도하게 크면 처음 할당된 메모리가 다 차버려서 새롭게 메모리를 재할당 해주는 일이 발생함. 그럴 경우에, 전체 데이터를 다른 메모리로 옮기기 때문에 O(N)의 복잡도가 발생하게됨 때문에 처음부터 메모리 크기를 K에 맞게 크게 할당한다? = array-based code가 됨

정리하면 k값이 큰데 arr가 적은 경우에 array-based code는 굉장히 비효율적일 수 있지만, arr도 그만큼 큰 경우 dictionary-based는 메모리 재할당이 발생할 수 있어서 오히려 비효율적일 수 있다는 얘기!!

문제 19. 문자열 해싱을 이용한 검색 함수 만들기

여기서 hash table을 직접 만드는데, 내가 할 엄두가 안나서 책을 그대로 따라함

## question 19

# string_list의 길이 N
# query_list의 길이 K
# string 한 개의 길이 M

def polynomial_hash(str):
    p = 31
    m = 1_000_000_007
    hash_value = 0
    for chr in str: # -- O(M)
        hash_value = (hash_value * p + ord(chr)) % m
    return hash_value

def solution(string_list, query_list):
    hash_list = [polynomial_hash(str) for str in string_list] # -- O(M*N)

    answer_list = []
    for query in query_list: # -- O(K)
        query_hash = polynomial_hash(query) # -- O(M)
        if query_hash in hash_list: # -- O(N)
            answer_list.append(True)
        else:
            answer_list.append(False)

    return answer_list

string_list = ['apple', 'banana', 'cherry']
query_list = ['banana', 'kiwi', 'melon', 'apple']

print(solution(string_list, query_list))

근데 의문인 점은 내가 생각하기에 이 문제의 시간복잡도는 O(K*(N+M)+M*N)인데 이 책에서는 O(K+N)으로 해석한다는 점..??

이 부분 이해가 안 감

그래서 내가 다시 해봄

내가 한 것 :

def solution_yb(string_list, query_list):
    string_dict = dict()
    answer_list = []
    for string in string_list:
        string_dict[string] = 1
    for query in query_list:
        if query in string_dict:
            answer_list.append(True)
        else:
            answer_list.append(False)
    return answer_list

이렇게 해서 시간 계산했을 때 solution_book이 훨씬 느린걸 보아.. 아무래도 list로 hash를 만든것 자체가 잘못되지 않았나 조심스럽게 문제제기를 해봅니다

문제 20. 완주하지 못한 선수

내가 한 것 :

## question 20

def solution(participant, completion):
    completion_dict = set(completion) ## - O(N)
    remain = []
    for p in participant:
        if p in completion_dict:
            continue
        else:
            remain.append(p)
    return remain

participant = ['leo', 'kiki', 'eden']
completion = ['eden', 'kiki']

print(solution(participant, completion))

내 의견 : dict도 그렇고 set도 그렇고 결국 hash 방식으로 데이터를 다루니까 특히 결국 hash table의 크기를 제한해서 초기화해서 메모리를 적절히 할당할 수 있는게 아니라면 직접 hash-table을 구현하는 것보다는 dict와 set를 사용하는게 적절하다고 생각함. 특히 지금처럼 유무만을 따지는 경우 dict를 사용하여 불필요한 value를 지정할 필요 없이 set으로 포함관계만 사용하면 되니까 더 적절하지 않나?

아, 근데 이 경우에 지금 동명이인이 있기 때문에 value 지정이 필요함;; dict로 해야할 듯

내가 수정한 것 :

## question 20

## question 20

def solution(participant, completion):

    completion_dict = {}

    for c in completion:
        if c in completion_dict:
            completion_dict[c] += 1
        else:
            completion_dict[c] = 1

    for p in participant:
        if p in completion_dict:
            completion_dict[p] -= 1
        else:
            return p

    for key, value in completion_dict.items():
        if value == -1:
            return key


# participant = ['leo', 'kiki', 'eden']
# completion = ['eden', 'kiki']
participant = ['mislav', 'stanko', 'mislav', 'ana']
completion = ['stanko', 'ana', 'mislav']
print(solution(participant, completion))

근데 예전의 내가 한걸 찾았는데 조금 더 똘똘함

from collections import Counter
def solution(participant, completion):
    participant = Counter(participant)
    for finisher in completion:
        participant[finisher] -= 1
        if participant[finisher] == 0:
            del participant[finisher]
    return ''.join([str(key) for key in participant.keys()])
participant = ['mislav', 'stanko','mislav', 'ana']
completion = ['stanko', 'ana', 'mislav']
print(solution(participant, completion))

일단 Counter를 사용해서 처음 O(N)짜리를 한줄로 표현하고 조건을 충족시키면 dictionary값을 0을 만드는걸 떠나서 걍 지워버림ㅋㅋㅋ 그래서 마지막 O(N)을 없앰 더 시간복잡도가 개선될 듯?

근데 programmers에서는 효율성과 정확도가 동일함;; 상수계수 차이는 정말 성능측면에서 미미하다고 합니다.. 물론 N이 엄청크면 조금 다르기야 하지만 그래도 아주 미미하다고 하네요;;

오히려 가독성 측면에서 programmers의 다른 답변 중에 가장 좋았던 답변은

import collections

def solution(participant, completion):
    answer = collections.Counter(participant) - collections.Counter(completion)
    return list(answer.keys())[0]

여기서 내가 몰랐던 것 : collections.Counter는 뺄셈이 가능하다!!

문제 21. 할인 행사

내가 한 것:

## question 21

from collections import Counter

def solution(want, number, discount):

    shop_list = {}

    for i in range(len(want)): # -- O(M)
        shop_list[want[i]] = number[i]

    buy_days = 0

    for j in range(len(discount)): # -- O(N)
        scope = Counter(discount[j:j+10]) # -- O(10)
        for product in want: # -- O(M)
            if (product in scope and scope[product] >= shop_list[product]):
                try_next_day = False
                continue
            else:
                try_next_day = True
                break
        if try_next_day:
            continue
        else:
            buy_days += 1

    return buy_days

want = ['banana', 'apple', 'rice', 'pork', 'pot']
number = [3, 2, 2, 2, 1]
discount = ['chicken', 'apple', 'apple', 'banana', 'rice', 'apple', 'pork', 'banana', 'pork', 'rice', 'pot', 'banana', 'apple', 'banana']
print(solution(want, number, discount))

답변을 보면 dict(scope) == shop_list로 표현했는데 이게 더 직관적이긴 하지만 제한이 좀 필요함 근데 문제에 그 제한이 다 적혀있음;;

또 무엇보다 내가 몰랐던 것💡

dictionary에서 없는 key값을 조회하려고 할 때, key-except를 썼었는데 여기서 유용한 method가 바로 get

a = {'yb':31, 'sb':32}
#방법 1
a['yb'] # 31
a['jm'] # Key error
#방법 2
a.get('yb') # 31
a.get('jm') # None
a.get('jm', 0) # 0

문제 22. 오픈 채팅방

내가 한 것:

## question 22

def solution(record):
    user = {}
    result = []
    for log in record:
        log = log.split()
        if log[0] in ['Enter', 'Change']:
            user[log[1]] = log[2]
    # print(user)
    for log in record:
        log = log.split()
        if log[0] == 'Enter':
            msg = f"{user[log[1]]}님이 들어왔습니다."
            result.append(msg)
        elif log[0] == 'Leave':
            msg = f"{user[log[1]]}님이 나갔습니다."
            result.append(msg)
    return result
record = ["Enter uid1234 Muzi", "Enter uid4567 Prodo", "Leave uid1234", "Enter uid1234 Prodo", "Change uid4567 Ryan"]
result = ["Prodo님이 들어왔습니다.", "Ryan님이 들어왔습니다.", "Prodo님이 나갔습니다.", "Prodo님이 들어왔습니다."]
print(solution(record))

굿!

문제 23. 베스트 앨범

내가 한 것 :

## question 23

def solution(genres, plays):

    # 가장 인기있는 장르 sorting + 장르별 노래 sorting
    genres_sum = {}
    musics = {}
    for i in range(len(genres)):
        genres_sum[genres[i]] = genres_sum.get(genres[i], 0) + plays[i]

        if genres[i] in musics:
            musics[genres[i]][i] = plays[i]
        else:
            musics[genres[i]] = {i:plays[i]}
    genres_order = sorted(genres_sum, reverse=True, key= lambda x : genres_sum[x])
    # print(musics)

    # 가장 인기있는 장르 순으로 노래 선곡
    album_list = []
    for genre in genres_order:
        # print(sorted(musics[genre], reverse=True, key = lambda x : musics[genre][x]))
        album_list += sorted(musics[genre], reverse=True, key = lambda x : musics[genre][x])[:2]
    return album_list
genres = ["classic", "pop", "classic", "classic", "pop"]
plays = [500, 600, 150, 800, 2500]
result = [4, 1, 3, 0]
print(solution(genres, plays))

내가 잘 몰랐던 것 :

sorted vs. sort sorted : python 내장함수. 주어진 argument(iterable object)를 정렬한 후에 새로운 list 형태로 반환한다 sort : list의 method. list를 정렬해서 변환시킨다. 원본 리스트를 바꾸기 때문에(in-place) 반환값 자체는 None이다

sorted sorted는 iterable object를 인자로 받고 key를 기준으로 정렬하는데, key에는 함수가 들어간다

예를 들면

a = ['banana', 'apple', 'kiwi']
sorted(a, key = len)
# ['kiwi', 'apple', 'banana']

또다른 예를 들어보자면

a = {'banana':3, 'apple':4, 'kiwi':5}
sorted(a, key = lambda x:a[x])
# ['banana', 'apple', 'kiwi']

또는,

a = {'banana':3, 'apple':4, 'kiwi':5}
sorted(a.items(), key = lambda x:x[1])

문제 24. 신고 결과 받기

내가 한 것 :

## question 24
def solution(id_list, report, k):
    result = []

    # user들의 complain list 초기화
    complained_list = {}
    complain_list = {}
    for id in id_list: # -- O(M)
        complained_list[id] = set()
        complain_list[id] = set()

    # report 분류
    for complain in report: # -- O(N)
        complain = complain.split()
        complained_list[complain[1]].add(complain[0])
        complain_list[complain[0]].add(complain[1])

    # 신고 당한 갯수 count
    for user in id_list: # -- O(M)
        mailing = 0
        for bad_user in complain_list[user]: # -- 최대 O(M) : 자기 빼고 전부 신고
            if len(complained_list[bad_user]) >= k:
                mailing += 1
        result.append(mailing)

    return result
id_list = ["muzi", "frodo", "apeach", "neo"]
report = ["muzi frodo","apeach frodo","frodo neo","muzi neo","apeach muzi"]
k = 2
result = [2, 1, 1, 0]
print(solution(id_list, report, k))

report의 길이를 N, id_list의 길이를 M이라고 했을 때 내가 짠 코드는 사실 O(N+M)~O(N+M+M^2)라고 할 수 있음 문제에서 N < 2e+5, M < 1e+3 이라고 제시했기 때문에 한놈이 찌를 수 있는 다른 사람의 수가 제한되긴함 그래도 좀 아쉬움..

다른 사람의 문제 풀이 중에 조금 신박한게 있다면 report 자체에 set을 취한 방법이 조금 새로움 근데 풀이 속도는 비슷해보임

def solution(id_list, report, k):
    answer = [0] * len(id_list)
    complained = {x:0 for x in id_list}
    reports = set(report)
    for r in reports:
        complained[r.split()[1]] += 1

    for r in reports:
        if complained[r.split()[1]] >= k:
            answer[id_list.index(r.split()[0])] += 1

    return answer

문제 25. 메뉴 리뉴얼

내가 한 것:

def solution(orders, course):
    orders_set = order_to_set(orders)
    intersect_dict = intersect(orders_set)
    intersect_dict_correct = intersect_dict.copy()
    answer = []
    for course_num in course:
        for menu_combi, order_count in intersect_dict.items():
            if len(menu_combi) > course_num:
                new_menu_combis = combination(menu_combi, course_num)
                for new_menu_combi in new_menu_combis:
                    if new_menu_combi in intersect_dict:
                        intersect_dict_correct[new_menu_combi] += order_count
                    else:
                        intersect_dict_correct[new_menu_combi] = order_count
    # print(intersect_dict_correct)
    for course_num in course:
        max_order = 0
        choose_menu = []
        for menu_combi, order_count in intersect_dict_correct.items():
            if len(menu_combi) == course_num:
                if order_count > max_order:
                    max_order = order_count
                    choose_menu = [menu_combi]
                elif max_order == order_count:
                    choose_menu.append(menu_combi)
        answer += choose_menu
    answer = set(answer)
    return sorted(answer)

def combination(menu_combi, course_num, start = 0, current = None, result = None):
    if current == None:
        current = []
    if result == None:
        result = []
    if len(current) == course_num:
        result.append("".join(current))
        # print(result)
        return result
    for i in range(start, len(menu_combi)):
        combination(menu_combi, course_num, i+1, current + [menu_combi[i]], result)
    return result

def intersect(orders_set):
    intersect_dict = {}
    while orders_set:
        current_check = orders_set.pop()
        for order_set in orders_set:
            find_intersect = current_check.intersection(order_set)
            if len(find_intersect) > 1:
                menu_combination = str()
                for menu in sorted(find_intersect):
                    menu_combination += menu
                if menu_combination in intersect_dict:
                    intersect_dict[menu_combination] += 1
                else:
                    intersect_dict[menu_combination] = 1
    return intersect_dict

def order_to_set(orders):
    orders_set = []
    for order in orders:
        order_set = set()
        for menu in order:
            order_set.add(menu)
        orders_set.append(order_set)
    return orders_set

테스트케이스에서 우르르쾅쾅인데 시간을 너무 오래 쏟을 수 없어서 여기까지..

pop(0)과 popleft() 연산을 비교했을 때, popleft()가 훨씬 1000배는 빠름!! 그렇기 때문에 queue를 사용할 때에는 list를 활용하기 보다는 deque를 queue로 활용할 것

DEQue = Double Ended Queue 양 끝에서 삽입과 삭제를 할 수 있는 큐를 구현한것이기 때문에 선입후출이 아닌 선입선출인 queue에서는 DEQue 자료구조를 사용하는 것이 좋음

DEQue를 활용하는 법

from collections import deque
queue = deque()

문제 15. 요세푸스 문제

내가 한 것:

## question 15
from collections import deque

def solution(N, K):
    peoples = deque(range(1, N+1))
    while len(peoples) != 1:
        for _ in range(K-1):
            peoples.append(peoples.popleft())
        peoples.popleft()
    return peoples[0]
print(solution(5, 2))

시간복잡도 O(N*K) 문제에서 N과 K는 1000이하 자연수 이므로 10^6이니까 10^8안쪽이라 괜찮음

문제 16. 기능 개발

내가 한 것:

## question 16
from math import ceil

def solution(progresses, speeds):
    release_day = 0
    release_funcs_num = 0
    release_funcs = []
    for i in range(len(progresses)):
        need_day = left_day(progresses[i], speeds[i])
        if need_day > release_day:
            release_funcs.append(release_funcs_num)
            release_day = need_day
            release_funcs_num = 1
        else:
            release_funcs_num += 1
    release_funcs.append(release_funcs_num)
    return release_funcs[1:]

def left_day(progress, speed):
    return ceil((100-progress)/speed)

# print(left_days(55, 5))

progresses = [93, 30, 55]
speeds = [1, 30, 5]
print(solution(progresses, speeds))

이 문제는 굳이 deque가 필요해 보이지 않는데.. popleft()를 사용하는 것도 아니고..

오 solution에서도 굳이 deque를 사용하지 않았군

보자보자 시간복잡도는 for문 하나 들어가니까 O(N)이군

문제 17. 카드 뭉치

내가 한 것:

## question 17

from collections import deque

def solution(cards1, cards2, goal):
    cards1 = deque(cards1)
    cards2 = deque(cards2)
    goal = deque(goal)
    card1 = cards1.popleft()
    card2 = cards2.popleft()
    while goal:
        target = goal.popleft()
        if target == card1:
            if len(cards1)>=1:
                card1 = cards1.popleft()
            else:
                card1 = None
            continue
        elif target == card2:
            if len(cards2)>=1:
                card2 = cards2.popleft()
            else:
                card2 = None
            continue
        else:
            return 'No'
    return 'Yes'


card1 = ['i', 'water', 'drink']
card2 = ['want', 'to']
goal = ['i', 'want', 'to', 'drink', 'water']

print(solution(card1, card2, goal))

내가 몰랐던 것: 처음에 cards1를 deque로 바꿀 때, 이 변환하기 위해서도 한번 list를 훑기 때문에 시간복잡도가 포함됩니다 그렇기 때문에, cards1과 card2의 사이즈를 N, goal의 사이즈를 M이라고 할 때, 시간복잡도는 O(N+M)입니다 또한, 나중에 while문으로 goal한번 싹 훑으니까 O(M)추가요~

의문 사항

deque에 보면 appendleft라는 함수도 있던데 이것도 혹시 시간복잡도가 O(N)이 아니라 O(1)인가?

애널리스트 투자 의견

Roth/MKM: Verona Pharma - HealthCare

https://kr.investing.com/news/analyst-ratings/article-93CH-1327619

• Roth/MKM : 투자 리서치를 제공하는 회사, Roth Capital(투자은행서비스) + MKM Partners(리서치 회사)

• Verona Pharma(NASDAQ: VRNA) : 호흡기 질환 치료제를 연구하는 제약회사 특히 만성폐쇄성폐질환과 같은 만성 호흡기 질환에 초점을 맞춘 신약 개발 위주

Verona Pharma의 Ohtuvayre라는 제품이 만성 폐쇄성 폐질환에서 차별화된 효과를 보인다고 생각. 재무상태도 아주 낙관적(잉여현금흐름이 양수가 될 것같음) 특히, 이 제품의 초기 판매 실적이 아주 인상적인대 2024년 4분기 매출이 3분기 대비 6.4배 증가.

현재 주가(25년 1월 12일) 45.20 정도인데, 목표주가가 47

Grupo Aeroportuario del Pacifico - Industrials

https://kr.investing.com/news/analyst-ratings/article-93CH-1327618

• GAP(Grupo AEroportuario del Pacifico SAB de CV, NYSE: PAC) : 멕시코 기반의 기업으로 주로 멕시코와 자메이카에서 공항 운영 및 관리 산업을 하는 회사

현재 PAC가 183.84인데 재무 건전성 점수가 참 좋음 2025년에 EBITDA가 30% 상당한 정도로 성장할 것 같음 왜? 멕시코 가중평균 요금의 26% 인상하는것이 승인되었고 = 가격을 올리는것을 규제 기관이 승인함 교통량이 3.9%로 회복될 것이라고 예측됨 = Volaris라는 저가 항송사의 Airbus 엔진리콜이 2025년 하반기에 끝나는데 그럼 항공 이용량이 엄청 늘어날 것으로 기대됨

현재 동종업계랑 비교했을 때 2025년 예상 기업 가치 대비 EBITDA 배수 10.8배로 거래되는데 이게 1.4배 높은 수준임. 그럼에도 성장률이 경쟁사 대비 2.8배 높기 때문에 주식이 약간 고평가 되어있다고 볼 수 있음

동종업계 경쟁사인 Asur(남동부지역)과 Oma(북부 및 중부지역)에 대해서도 긍정적으로 전망하고 있음

EBITDA : 이자, 세금, 감가상각비, 무형자산상각비를 차감하기 전의 순이익 영업활동의 수익성을 평가하는데에 사용됨. 이자 비용이나 세금 등 외부 요인을 제거해 순수한 기업 운영 효율성을 파악할 수 있게 함 EV : 기업가치 기업의 시가총액, 부채, 현금 및 현금성 자산을 포함한 총 가치 => EV / EBITDA = 10 : 기업가치 대비 EBITDA 배수 10배 (=영업이익 대비 10배정도의 가격으로 기업가치가 매겨져 있다) 일반적으로 저성장은 58배, 성장성 있으면 812배, 고정상은 12배 이상 정도이다

뉴스 속보

2025년 미국 항공우주 및 방위산업에 대한 전망

Jefferies, UBS, Barclays 등 3개 투자은행의 애널리스트 전망 https://kr.investing.com/news/pro/article-432SI-1327587

OE(Original Equipment) : 원제품 또는 원래 제조된 제품 자동차 부품이나 기계정비같은 것으로 OE부품은 원래 장착된 부품을 의미함

AM(After Market) : 제품을 처음 판매한 이후에 발생하는 시장. 기존 제품을 사용한 후에 교체나 추가되는 부품에 대한 시장

DOGE(Department of Government Efficiency) : 트럼프 2기의 새로운 정책으로 정부의 비효율적인 지출을 줄이고 관료주의에서 기술제한을 벗어나도록 하는 것이 목적

국방/IT 서비스의 2025년 키워드는 불확실성! 득히 연방 예산 삭감이나 DOGE 리스크 등이 불확실하기 때문에 이를 헷지하기 위해서 바벨접근법을 권장함 - UBS

OE부문에서 주목할만한 종목은 보잉(NYSE:BA)과 AM부문에서는 GE Aerospace(GE), 그리고 양쪽 모두에서 Woodward Inc. (NASDAQ:WWD) 국방부 투자 성장이 예상되는데 Northrop Grumman(NYSE:NOC)도 매수 추천 CACI International(CACI) 매수 추천 - UBS

2025년 항공기 생산이 20% 증가하고 상업용 OE 매출이 15% 증가할 것으로 추정됨. 이로 인해 상승여력이 있음. AM비중이 높은 FTAI Aviation(FTAI), Heico Coporation(HEI), Transdigm Group Inc(NYSE:TDG), GE를 꼽고 OE 종복으로는 보잉과 Howmet Aerospace(HWM), 국방/IT 서비스에서는 Parsons Corp.(NYSE:PSN)을 선호 - Jefferies

AM보다 OE에서 더 많은 상승여력이 있기 때문에 OE의 대표주자인 보잉을 상향 조정한다. AM에서는 GE를, 방위산업에서는 L3Harris Technologies(NYSE:LHX)를 선호하지만 DOGE 불확실성과 예산 리스크로 인해 방위산업 자체를 예상하기 어렵다. 서비스 부문에서는 CACI를 선호한다 - Barclays

미국 항공사 주식에 대한 정망

https://kr.investing.com/news/pro/article-432SI-1327595 미국 항공사들이 2024년 시가총액이 46% 성장한 고성장의 해를 보냈고 앞으로 2025년에도 그 기세가 이어질 것으로 기대됌 일반적으로 미국 항공사들의 EV/EBITDA 기준 다른 sector들 대비 낮게 거래되기 때문에 아직 충분히 더 오를 여력이 있다고 평가 선두 주자와 후발 주자간의 마진 격차가 억제될 것으로 기대됨

Delta Airlines(NYSE:DAL), United Airlines(UAL), 아메리칸항공그룸(NASDAQ:AAL)

2025년 Utility 기업 성장동력은 데이터센터

https://kr.investing.com/news/pro/article-432SI-1327620

Jefferies

• Utility : 전력, 가스, 물공급

작년에 중요했던 Data Center가 계속해서 지역의 매출 성장 Guidance를 주도하고 EPS 성장률을 개선할 것 특히, 데이터 센터를 발표하고 나서 실제 상업 운영 개시까지 약 3-4년의 시차가 있는데 2025년에 데이터 센터의 부하가 발표되었으니 2030년까지 유틸리티 기업들의 EPS 성장률이 좋을 것

즉, Utility 기업의 예상 EPS 성장률을 파악하려면 데이터 센터로 발표된 부지의 총 범위를 고려해야한다.

관련 주식 : Evergy(NASDAQ:EVRG), 니소스(NYSE:NI), Alliant Energy Corp(NASDAQ:LNT), Public Service Enterprise Group(NYSE:PEG), PPL corporation(NYSE:PPL) OGE Energy Corporation(NYSE:OGE), Duke Energy Corporation(NYSE:DUK)

EPS(Earnings Per Share) : 주당 순이익

증권사 리포트

나무 증권

1월 유망 종목 : CES 모멘텀

1월의 CES 행사 때문에 엔비디아(NVDA)가 주목핟고 있음 로봇이 글로벌 주식 시장 테마가 된다면 대형주 내에서는 테슬라, 아마존 닷컴, 엔비디아 중형주에서는 테라다인 소형주는 Serve Robotics, Pony AI로 대응할 것을 권고 빅테크 주가가 횡보 중으로 미래기술(우주, 전고체, UAM, 양자컴퓨팅 등) 관련주는 리스크 관리가 필요하다 AI 코어주의 부분 차익실현으로 비중 관리 조언

*유망주 : 로블록스(RBLX), 유나이티드 에어라인스(UAL)

삼성 증권

1월 2주차 추천 종목

AI 하드웨어: NVDIA, TESLA, TSMC ADR, 브로드컴 AI 소프트웨어: Alpabet, Amazon, 세일즈포스, 팔란티어 테크놀로지스 트럼프 당선 수혜: 캐터필러, 셰니어 에너지

2023년 2024년 S&P500의 연간 성과가 2년 연속 20%대를 넘었는데 이게 사실 지난 역사 상 굉장히 이례적으로 유사한 상승세를 기대하기 어려움 (3년 연속 강세장은 어렵지 않을까?)

하지만 2022년에 조정이 있었었기 때문에 평균으로는 26.3인데 평균내면 3년 성과는 31% 이기 때문에 과도하다고 보기 힘들다는 의견도 있음

미 경제의 차별적인 강건성과 기업실적은 충분히 주가 상승을 지지하고 미 증시에 비교할만한 후보군이 없음

2025년 AI 산업의 기념비적인 해가 될 것으로 기대됨 그래서 지금 저점 매수세가 유입될 수 있어 보임. 최근 가격조정을 겪었지만 실적 전망은 계속 상승해서 매력적인 수준이 되어버림.

종합 : 항공주에 대한 관심이 높은듯? AI관련 기술주가 횡보하고 있는데 이게 조정이고 저점 매수 기회라고 보는 의견과 리스크가 있다고 보는 의견이 나뉜다고 느껴짐

이 섹터 분류는 GICS(Global Industry Classification Standard)라는 표준에 기반함

1. 에너지 Energy

석유, 가스, 에너지 장비 및 서비스 Exxon Mobil이나 Chevron같은 회사가 포함된다는데 잘 모름 에너지 가격(원유, 천연가스 등)에 크게 영향을 받으며, 주기적 변동이 큼!

2. 소재 Material

화학, 건축자재, 금속 및 광업 DuPont, Dow Inc.가 대표적 원자재 가격과 글로벌 수요에 민감함 경기 회복기에 보통 강세를 보임

3. 산업재 Industrials

항공우주, 방위산업, 건설 및 기계 경제 성장과 인프라 투자에 따라 성장이 촉진됨 보잉같은 회사가 포함됨

4. 유틸리티 Utilities

전력, 가스, 물 공급 등 NextEra Energy, Duke Energy 안정적인 배당과 방어적 성격을 가진 섹터로 경기 불황 시에 선호됨.

5. 헬스케어 Healthcare

제약, 바이오테크, 의료장비, 헬스케어 서비스 Johnson & Johson, Pfizer 고령화 사회와 기술 혁신에 따라 지속 성장 가능성이 높음

6. 금융 Financials

은행, 보험, 자산운용, 투자 JPMorgan Chase, Goldman Sachs 금리와 경제 활동에 큰 영향을 받으며, 경기 확장기에 성과가 우수함

7. 임의소비재 Consumer Discretionary

자동차, 호텔, 소매업, 레스토랑 Amazon이나 Tesla같은 주식이 여기에 포함됨 경제 상황에 따라 수요 변동이 크며, 소비자 지출에 민감함

8. 필수소비재 Consumer Staples

식료품, 음료, 가정용품 Procter & Gamble이나 코카콜라가 대표적 경기 방어적 섹터로 경제 불황이 와도 안정적인 성과를 보이는 경우가 많음

9. 정보통신기술주 Information Technology

소프트웨어, 하드웨어, 반도체 Apple, Microsoft 우리가 일반적으로 말하는 기술주들을 의미하며 혁신과 성장성이 큰 섹터로 장기적으로 높은 수익을 기대할 수 있음

10. 커뮤니케이션 서비스 Communication Services

통신, 미디어, 엔터테인먼트 Alphabet, Meta Platform이 대표적 인터넷 및 디지털 광고 산업의 성장에 크게 의존

11. 부동산 Real Estate

부동산 투자 신탁, 부동산 서비스 American Tower, Prologis가 대표적 배당 수익률이 높은 섹터로 금리 환경 변화에 민감

재개발은 도시정비사업이기 때문에 "도시 및 주거환경정비법"을 따름 또한, 사업 추진을 위해 충족해야 하는 요건 (주택 접도율, 과소 필지 노후도 요건) 등은 규정 범위 내에서 각 지자체가 조례로 별도 지정도 가능함 그래서 세부적인 사항은 지역마다 조금 다를 수 있음

재개발 방식

• 신속통합기획
• 모아타운
• 민간재개발
• 공공재개발

등등 => 재개발 방식

재개발 절차

1. (사업 준비) 기본 계획 수립 - 약 5년
2. (사업 준비) 정비 구역 지정 - 약 1년
3. (사업 시행) 추진위원회 구성 - 약 2~3년
4. (사업 시행) 조합설립 인가 - 약 1년
5. (사업 시행) 사업시행 인가 - 약 2년
6. (관리 처분) 관리처분계획 인가 - 약 1년
7. (완료) 이주 및 철거 - 약 3년
8. (완료) 입주 후 이전고시 - 약 1년

1. 기본 계획 수립

재개발 구역의 노후도, 동의율, 호수밀도, 접도율 등을 조사해서 정비 기본 계획을 수립 사전타당성 검토 조사라고 할 수 있음 원래는 시나 지자체가 수립하는 정비 기본 계획에 따라 정비구역 지정을 하기 위한 움직임이지만 요즘에는 주민들이 자의로 나서서 추진하는 곳도 많음

• 기본 계획 수립 => 시장 / 군수 / 구청장
  • 주민 공람 (14일 이상)
  • 지방의회 의견청취
  • 지방도시계획위원 심의
• (재건축) 안전진단 => 시장 / 군수 / 구청장

이 단계에서 행위제한이 걸리기도 하는데, 이럴 경우 재개발에 대한 기대감이 높아져 가격 상승

어떤 방식의 재개발을 하느냐에 따라서 노후도, 호수밀도, 접도율의 기준은 달라질 수 있음 각각의 자세한 정의 => 노후도, 접도율, 호수밀도, 과소필지

2. 정비 구역 지정

정비 기본 계획을 바탕으로 정비 구역을 지정하고, 권리 산정일을 고시 이 단계에서 토지와 건출물의 소유자들이 입주권을 얻을 수 있는지 여부가 결정됨 권리 산정일 이후에 지어지는 신축에 대해서는 입주권이 주어지지 않음 보통 정비구역 지정일이 권리 산정일이 되는데, 경우에 따라 먼저 고시하기도 함

• 정비 계획 수립 & 정비 구역 지정 => 시장 / 군수 / 구청장
  • 주민 공람 (30일 이상)
  • 지방의회 의견청취
  • 지방도시계획위원 심의

3. 추진위원회 구성

구역이 지정된 이후, 해당 지역 주민들이 직접 추진위원회를 구성해서 지자체로부터 승인을 받아야 함.

예비 조합원(토지 등 소유자) 과반수 이상의 동의서를 받아야함. 이게 빠르면 1년이지만 2~3년 정도 걸리기도함. 추진 위원회 구성에 동의한 토지 등 소유자는 나중에 있을 조합설립에도 동의한 것으로 보기 때문에 조합설립 인가 신청 전에 별도로 조합설립에 반대한다는 의사를 표현하면 동의를 취소할 수 있음

추진 위원회가 승인되면 추진 위원장을 투표로 선정하고, 조합 설립 인가를 위한 준비를 하는데 조합 설립 인가를 위해서는 토지등소유자 75% 이상의 동의가 필요하고, 동의한 사람들의 소유 토지 면적이 사업장 전체 토지의 50% 이상이어야함.

이게 말도안되게 힘듦.

• 조합 설립 추진 위원회 => 시장 / 군수 / 구청장 ※ 정비사업전문관리업자 선정 (필요시)

4. 조합설립 인가

조합설립 동의요건으리 충족하면(75%), 추진위는 지자체에 조합설립인가 신청을 하고, 검토결과 특별한 하자가 없다면 조합설립인가가 이뤄짐

조합설립 인가된 날부터 30일 이내에 조합사무소가 소재할 지역 등기소에 법인등기를 하면 정식으로 조합이 설립됨

조합이 설립되면, 추진위가 진행과정을 조합에 인수인계하고 해산 조합이 설립되면 사업을 추진할 수 있는 주체가 생긴 것이고, 법적인 지위까지 확보한 상태

조합은 하나의 사업 법인으로 간주되므로 운영이나 회계 처리를 할때 법의 제한을 엄격하게 받음.

서울시의 경우 사업 시행 인가 이후 시공사를 선정하도록 되어있고, 정비사업의 행정적, 재정적 지원은 지자체가 담당하고 있음 나머지 지역은 보통 조합설립인가 이후 시공사를 선정

5. 사업시행 인가

조합이 정비 사업의 내용을 시, 군, 구에 제출하고 검토와 인가를 받음 이 때 총 대지면적, 용적률, 건폐율, 기부채납 면적, 건축면적 및 평형 구성, 신축아파트 세대수, 임대아파트 세대수 등이 확정됨 즉, 사업의 구체적인 내용을 확정하는 단계

사업시행 인가를 받으면, 조합은 종전자산평가에 돌입 ※ 종전자산평가 = 재개발 구역 내의 소유자들이 소유하고 있는 자산 가치 측정

이 때, 정확한 감정평가액이 산정됨. 감정평가액에 높게 나오면 그만큼 추가 분담금이 줄어들기 때문에, 얼마로 확정 통보를 받느냐에 따라 조합원들의 희비가 갈림

또한, 조합 전체의 자산평가도 매우 중요한데, 조합 전체의 자산평가액, 필요한 총 사업비, 일반 분양 등을 통해 얻게될 수익이 정해져서 추가 분담금도 산출되기 때문

조합에서 사업시행 인가 고시일부터 120일 이내에 조합원들에게 감정평가액과 대략적인 추가 분담금을 통지하고, 조합원 분양신청기간을 고시

조합원들은 이를 확인하고, 분양 신청 기간동안 희망 평형을 신청. 이때 신청하지 않으면 현금청산자로 분류

6. 관리처분계획 인가

조합의 큰 틀이 정해짐

일반분양 세대수 및 예상 일반 분양가, 시공사 및 예상 공사 비용, 예상 분양 수익 등을 구체적으로 계산 가능

이 시기에는 재개발에서 사업성을 나타내는 지표인 비례율 역시 추정 가능 관리처분인가까지 이뤄졌다면 중간에 무산될 가능성 아주 낮음 시세도 높게 형성되어 있는 편이고, 이주비 대출을 활용해 투자금을 줄일 수도 있음.

비례율 100% 이상이 될수록 사업성이 좋음. 비례율은 아파트가 완성될 때 까지 계속 바뀜

7. 이주 및 철거

관리처분 인가 이후 조합에서 312개월 전에 이주공고 고시 이주날짜를 고시해서 이주비를 주는데, 보통 감평액의 4060%를 무이자 대출로 제공하고 입주시에 상환하도록 함.

이주가 다 되면 착공신고를 하고 일반분양 준비 일반분양이 얼마나 성공적으로 이뤄지냐가 정말 중요함. 전체 사업성을 높이는데 매우 중요한데, 일반분양이 높은 가격에 잘 되면 수익금이 많아져서 분담금이 줄지만, 그렇지 않으면 조합원들이 고스란히 부담함

8. 입주 후 이전고시

일반 분양이 끝나면 23년 이후 입주 시작 입주하고 바로 등기가 나오진 않고 13년 정도 시간이 걸린 후 집합건물의 등기가 나옴

이전고시가 완료된 후 사업내용을 청산하면 모든 절차 완료.

참고 블로그 : 정직한 분양 길라잡이, 젠틀홍, 엄마이야기

• 구역 면적
• 노후도(동수/연면적)
• 호수밀도
• 과소필지
• 주택접도율

이 용어에 대해 무엇인지 알아봅시다

노후도

노후/불량 건축물의 범위

노후도를 이해하기 위해 노후/불량 건축물의 범위에 대해 이해해야 하는데 이는 도시 및 주거환경 정비법에 언급되어 있음 => 도시 및 주거환경정비법 시행령 => "준공된 후 20년 이상 30년 이하의 범위에서 시.도조례로 정하는 기준이 지난 건축물"

=> 시.도 조례(서울시)

노후도 확인하는 방법

=> 부동산 플래닛 접속해서 탐색 버튼의 노후도를 클릭하면 시각적으로 확인 가능

호수밀도

건물이 밀집되어 있는 정도를 나타내는 지표로써 정비구역 면적 1헥타르(1만 제곱미터)당 건축되어 있는 건축물의 동수

주택점도율

폭 4m이상 도로에 길이 4m이상 접한 대지의 건축물의 총수를 구역 내 건축물 총수로 나눈 비율 즉, 4m 이상 도로와 접하고 있는 건축물이 적은 곳

과소필지

토지면적이 90m^2 미만인 토지 어떤 행위(건물을 짓는 등)을 하기에 어려운 작은 땅

참고 블로그 : 행복 나침반

노후도/호수밀도/과소필지/주택접도율 확인방법

어플로 바로 노후도를 확인할 수 있는 부동산 플래닛 말고 노후도/호수밀도/과소필지/주택접도율을 모두 확인할 수 있는 곳

Prom

말 그대로 쌓아 올린다

내가 책더미에 책을 추가하고 싶으면 맨 위에 올리고 = push 원하는 책을 빼고 싶을 때에도 맨 위에서부터 차례로 빼는 = pop

이걸 FILO(Firs In Last Out)이라고 표현 = 선입후출

python에서는 stack을 제공하지 않기 때문에 대안으로 list의 append나 push로 스택을 대체하거나 deque를 응용해서 stack처럼 사용함 그러니까 stack이 실제로 존재하는 자료형은 아님!

하하 그러니까 정리하면 python에는 stack이 없어 그래서 stack을 쓰고 싶으면 네가 구현해야돼 stack은 ADT(Abstract Data Type)으로 실제 자료형으로 있는게 아닌 추상자료형!

Stack의 구현

stack에서는 어떤 연산이 있어야 할까?

• push
• pop
• isFull
• isEmpty
• top

stack = []
max_size = 10

def push(stack, item):
    if isFull(stack):
        print('stack이 가득 찼습니다')
    else:
        stack.append(item)

def pop(stack):
    if isEmpty(stack):
        print('stack이 비어있습니다')
        return None
    else: return stack.pop()

def isFull(stack):
    return len(stack) == max_size
def isEmpty(stack):
    return len(stack)==0

더 쉽게쉽게 발전시켜보면?

stack = []

# stack push = list append
# stack pop = list pop

문제 08. 괄호 짝 맞추기

내가 푼 답 :

def solution(strings):
    begin = 0
    end = 0
    for string in strings:
        if string == '(':
            begin += 1
        elif string == ')':
            end += 1

        if begin < end:
            return False

    if begin == end:
        return True
    else: return False

내가 stack으로 풀려고 노력해서 푼 답:

def solution(strings):
    stack = []
    for string in strings:
        if string == "(":
            stack.append(1)
        else:
            try:
                stack.pop()
            except:
                return False

    if len(stack) == 0:
        return True
    else: return False

문제 09. 10진수를 2진수로 변환하기

내가 한 것:

def solution(number):
    # 10 = 2**3 + 2**1
    # 10 = 5*2 = (2*2 + 1) *2
    stack = []
    done = True
    while done:
        if number // 2 == 0:
            done = False
        else:
            stack.append(number % 2)
            number = number // 2
    stack.append(1)
    stack = stack[::-1]
    return stack
    ## list 묶음을 어떻게 string으로 만들지..

내가 한 것 ver2:

def solution(number):
    # 10 = 2**3 + 2**1
    # 10 = 5*2 = (2*2 + 1) *2
    result = ''
    while number // 2 != 0:
        result += str(number % 2)
        number = number // 2
    result += '1'
    result = result[::-1]
    return result

문제 10. 괄호 회전하기

def correct_case(question):
    # small bracket : ()
    # medium bracket : []
    # large bracket : {}
    stack = []
    for candid in question:
        if candid == "(" or "{" or "[":
            stack.append(candid)
        else: 
            if not stack:
                return False
            elif (candid == ")") and (stack[-1] == "("):
                stack.pop()
            elif (candid == "]") and (stack[-1] == "["):
                stack.pop()
            elif (candid == "}") and (stack[-1] == "{"):
                stack.pop()                
            else: return False

    if stack: return False
    else: return True

def rotate_string(string):
    return string[1:]+string[0]

def solution(s):
    result = 0
    for x in range(len(s)):
        if correct_case(s): result += 1
        s = rotate_string(s)
    return result

문제 11. 짝지어 제거하기

내가 쓴 답

def solution(s):
    stack = []
    for alphabet in s:
        if len(stack) == 0:
            stack.append(alphabet)
        elif stack[-1] == alphabet:
            stack.pop()
        else:
            stack.append(alphabet)
    return 1 if len(stack) == 0 else 0

내가 아쉬운 점 True/False boolen을 반납하는 함수의 활용

def solution(s):
    stack = []
    for a in s:
        if stack and stack[-1] == a:
            stack.pop()

        else:
            stack.append(a)
    return int(not stack)

문제 12. 주식 가격

내가 한 것

def solution(prices):
    answer = [0] * len(prices)
    for i in range(len(prices)):
        day = 0
        for future_price in prices[i+1:]:
            if future_price >= prices[i]:
                day+=1
        answer[i] = day
    return answer 

시간복잡도가 지금 O(N^2)임 그래서 이 문제의 답이 될 수 없고 stack을 활용하지도 않았음

이렇게 푸는 방식에서 불필요한 연산을 줄여 효율성을 확인해야함

그리고 일단 나 문제 잘못이해함 :> 다시 해보자

문제 13. 크레인 인형 뽑기 게임

내가 한 것

import numpy as np

def solution(board, moves):
    board = np.array(board).T
    result = 0
    stack = [0]
    for move in moves:
        for idx, doll in enumerate(board[move-1]):
            if doll != 0:
                board[move-1][idx] = 0
                if stack[-1] != doll:
                    stack.append(doll)
                else: 
                    stack.pop()
                    result += 1
                break
    return result*2

문제 14. 표 편집

내가 한 것:

def solution(n, k, cmd):
    result = ["X"]*n
    info = list(range(n))
    backup = []

    for command in cmd:
        if command.startswith('U'):
            _, stair = command.split(' ')
            k -= int(stair)
        elif command.startswith('D'):
            _, stair = command.split(' ')
            k += int(stair)
        elif command.startswith('C'):
            backup.append(info.copy())
            candid = info[k] 
            info.remove(candid)
            if k > len(info):
                k = len(info)
        elif command.startswith('Z'):
            info = backup.pop()
        else: print('wrong command')

    for mem in info:
        result[mem] = 'O'

    return ''.join(result)

내가 못한 것: stack의 활용 직접 배열을 계속 살려서 가져가면 시간이 많이 듬 특히 remove가 생각보다 시간을 오래 쓰는 것 같음 한바퀴를 돌아서 찾는 것 같음 답지에서는 순서를 기억해서 쓰는 방식으로 배열을 건드리지 않으며 효율을 높임

답지:

배열 index와 value를 일대일 대응해 관리하는 자료구조 데이터를 저장할 수 있는 모든 공간이 index와 일대일 대응하므로 어떤 위치에 있는 데이터든 한번에 접근할 수 있음 (=random access)

배열 데이터는 임의 접근 random access 으로 배열의 모든 위치에 있는 데이터에 단 한번에 접근할 수 있기 때문에 데이터에 접근하기 위한 시간복잡도는 O(1)

그럼 배열에 데이터를 추가로 삽입/삭제할 때에는?

때문에 배열을 선택할 때 배열의 장/단점을 잘 생각해야 함

배열의 데이터에 자주 접근한다면 배열이 효율적이지만 메모리 공간을 충분히 필요로 하기 때문에 메모리 낭비가 발생할 수 있음

그러므로 아래의 두 가지 주의사항이 있다.

1. 할당 가능한 메모리의 크기 확인할 것
2. 중간에 데이터 삽입/삭제가 많은지 확인할 것

문제 01. 배열 정렬하기

내가 한 것 :

def solution(x):
    if not isinstance(x, list):
        return None
    x_sorted = x.sort()
    return x_sorted

내가 아는 것 : 배열을 정렬하는 함수

내가 모르는 것 : 문제의 제약조건의 활용법

제약조건 :

1. 정수 배열의 길이는 2이상 10^5이하

2. 정수 배열의 각 데이터 값은 -100,000이상 100,000이하

3. 배열의 길이 최대값 : 10^5 제한시간이 3초라면, 초당 100,000,000번(10^8) 연산을 최대라고 보통 계산하기 때문에 O(N)이면 10^5회 O(N2)이면 10^10회 연산이 필요하다고 생각해 볼 수 있음(최소 100초는 필요하겟는데;;) 그래서 만약에 for문으로 배열을 하게되면 해당 문제는 틀릴수 밖에 없다 참고로 sort의 시간복잡도는 O(NlogN)

문제 02. 배열 제어하기

내가 한 것 :

def solution(arr):
    arr_unique = list(set(arr))
    return arr_unique.sort(reverse=True)    

내가 아는 것 : set함수, sort함수

내가 모르는 것 : 시간 복잡도 계산

1. list->set : O(n)*O(1)=O(n)
2. sort : O(nlogn)

최종 시간 복잡도는 O(NlogN)

문제 03. 2개 뽑아서 더하기

제약조건 :

1. numbers의 길이는 2이상 100이하
2. numbers의 모든 수는 0 이상 100이하

내가 한 것 :

def solution(numbers):
    pairs = []
    n = len(numbers)
    for i in range(n):
        for j in range(n):
            if i == j:
                pass
            else:
                sum_pair = n[i]+n[j]
                pairs.append(sum_pair)
    pairs_sorted = list(set(pairs)).sort()

내가 아는 것 : 풀이 방법, 대략적인 시간 복잡도 내가 모르는 것 : A+B=B+A라는 것( j는 굳이 1부터 시작하지 않아도 되었음), 정확한 시간 복잡도

1. for 문 2번 : O(n^2)
2. list의 sort : O(NlogN)인데 N<=n^2이므로 O(n^2logn^2)

여기서 n은 100이기 때문에 10000*4 정도니까 1초안에 풀림!

문제 04. 모의고사

내가 한 것 :

def solution(answers):
    ques_num = len(answers)
    a_answers = ques_num//5 * [1, 2, 3, 4, 5] + [1, 2, 3, 4, 5][:ques_num%5]
    b_answers = ques_num//8 * [2, 1, 2, 3, 2, 4, 2, 5] + [2, 1, 2, 3, 2, 4, 2, 5][:ques_num%8]
    c_answers = ques_num//10 * [3, 3, 1, 1, 2, 2, 4, 4, 5, 5] + [3, 3, 1, 1, 2, 2, 4, 4, 5, 5][:ques_num%10]
    correct = [0, 0, 0]

    for i in range(ques_num):
        if a_answers[i] == answers[i]:
            correct[0] += 1
        if b_answers[i] == answers[i]:
            correct[1] += 1
        if c_answers[i] == answers[i]:
            correct[2] += 1        
    max_grade = max(correct)
    winner = []
    for candi in range(3):
        if correct[candi] == max_grade:
            winner.append(candi+1)
    return winner

문제 05. 행렬의 곱셈

내가 한 것 :

def solution5(arr1, arr2):

    r1, c1 = len(arr1), len(arr1[0])
    r2, c2 = len(arr2), len(arr2[0])

    res = [[0]*c2 for _ in range(r1)] # 여기서 한참 해맴

    for i in range(c2):
        for j in range(r1):
            for k in range(c1):
                print("a: ", arr1[j][k])
                print("b: ", arr2[k][i])
                res[j][i] += arr1[j][k] * arr2[k][i]
            print("c: ", res[j][i])

    return res

내가 아는 것 : 코드 짜는 법 내가 모르는 것 : immutable과 mutable

내가 처음에 짠 것 :

res = [[0] * c2] * r1

>
> 이렇게 하면 어떻게 되는지 하나씩 살펴보면,
>
0 ← int (immutable)
>
[0] * 2 = [0] + [0] = [0,0] 
:  첫번째와 두번째 모두 같은 위치의 0을 참조함
>
>[0,0] ← list (mutable)
>
>[[0, 0]] * 3 = [[0, 0], [0, 0], [0, 0]]
: 첫번째, 두번째, 세번째 모두 같은 [0,0]을 참조함
>
>> ```python
a = [[0, 0]]*3
a[0][0]=3 
print(a) #[[3, 0], [3, 0], [3, 0]]

list는 mutable하기 때문에 같은 위치의 list 자체가 변경됨

b = [[0]*2 for _ in range(3)]
b[0][0]=3
print(b) #[[3, 0], [0, 0], [0, 0]]

>
> for을 통해서 반복하면 매번 새로운 리스트를 만듦

내가 연습할 것 : 시간복잡도 계산
n = 100
O(n^3)


## 문제 06.  실패율


답지를 참고하여 해낸 것
```python
def solution(N, stages): 
    """
    N : stage 갯수
    stages : 게임을 이용하는 사용자가 현재 멈춰있는 스테이지 번호 배열
    """

    # stage별 player명 수
    players = [0]*(N+2)
    for stage_on_player in stages:
        players[stage_on_player] += 1

    challengers = [0]*(N+2)
    for i in range(N+1, 0, -1):
        challengers[i] = sum(players[i:])

    fail_rates = {}
    for i in range(1, N+1):
        if challengers[i] == 0:
            fail_rates[i] = 0
        else:
            fail_rates[i] = players[i]/challengers[i]

    result = sorted(fail_rates, key=lambda x : fail_rates[x], reverse = True)
    return result

내가 모르는 것 :

## sort vs. sorted
a = list([1, 2, 4, 3])

### sort => list.sort() : list 객체의 method
a.sort() # -> a = [1, 2, 3, 4]
a.sort(reverse=True) # -> a = [4, 3, 2, 1]

### sorted => sorted(list) : python의 내장함수(iterable 객체를 정렬된 리스트로 반환)
b = sorted(list) # -> a = [1, 2, 4, 3], b = [1, 2, 3, 4]

## sort와 sorted의 key 인자
data = [(1, 3), (2, 2), (3, 1), (2, 1)]

sorted_data = sorted(data, key = lambda x:x[1])
print(sorted_data) # [(3, 1), (2, 1), (2, 2), (1, 3)]

data.sort(key = lambda x:x[1])
print(data) # [(3, 1), (2, 1), (2, 2), (1, 3)]

## 여러개의 key로 순서를 조절할 때
data = [(1, 3), (2, 2), (3, 1), (2, 1)]

sorted_data = sorted(data, key = lambda x: (x[0], -x[1]))
print(sorted_data) # [(1, 3), (2, 2), (2, 1), (3, 1)]

시간복잡도 계산 : 스테이지 갯수 N은 1과 500 이하의 자연수 stages의 길이 M은 1이상 200,000이하

1초면 10e8니까, 최대 시간 복잡도는 O(NM)이거나 O(MlogM) 제곱이 들어가면 안됨 (=for문이 겹쳐 들어가면 안됨)

내가 만든 코드의 시간복잡도는 첫번째 for문에서 O(M) 두번째 for문에서 O(N) => O(M+N) : challengers 계산 세번째 for문에서 O(N) : fail_rates 계산 네번째 정렬(sorted)할때, 시간 복잡도 O(NlogN) => O(2N+M+NlogN)

문제 07. 방문 길이

input인 dirs의 길이는 500이하의 자연수

내가 한 것:

def solution(dirs):
    ini_pos = (0, 0)
    path = []
    min_pos = -5
    max_pos = 5
    for i, dir in enumerate(dirs):
        if i == 0:
            pre_pos = ini_pos
        else:
            pre_pos = path[i-1][1]

        if dir == 'U':
            cur_pos = [pre_pos[0], pre_pos[1]+1]
        elif dir == 'D':
            cur_pos = [pre_pos[0], pre_pos[1]-1]
        elif dir == 'L':
            cur_pos = [pre_pos[0]-1, pre_pos[1]]      
        elif dir == 'R':
            cur_pos = [pre_pos[0]+1, pre_pos[1]]

        if cur_pos[0] > max_pos : cur_pos[0] = max_pos
        elif cur_pos[0] < min_pos : cur_pos[0] = min_pos
        elif cur_pos[1] > max_pos : cur_pos[1] = max_pos
        elif cur_pos[1] < min_pos : cur_pos[1] = min_pos

        cur_pos = tuple(cur_pos)
        path.append([pre_pos, cur_pos])

    visited_path = set()
    for line in path:
        line.sort()
        if line[0] == line[1]:
            continue
        line = tuple(line)
        visited_path.add(line)

    return len(visited_path)

기본 데이터 타입

• 정수형 int
• 부동소수형 float
• 문자열 string

epsilon을 포함한 연산에 주의할 것

float data를 표현할 때 이진법을 사용하기 때문에 반드시 오차가 발생함 즉, 0.1+0.1 != 0.2 인 현상이 발생함이 부분을 항상 생각할 것

컬렉션 데이터 타입

• 리스트 list
• 튜플 tuple
• 딕셔너리 dictionary
• 집합 set
• 문자열 string

  mutable object

  list, dictionary, set

mutable 객체의 수정은 어떻게 동작할까?

my_list = [1, 2, 3, 4, 5]
my_list[4] = 6

이렇게 값을 수정하면 my_list가 참조하고 있던 값이 수정됨

immutable object

tuple, int, float, string

a = 4
b = a
b += 2

이렇게 하면 처음 b를 정의할 때는 a가 참조하고 있던 위치를 참조하지만 4(int)는 immutable object이기 때문에 수정하지 못하고 새로운 참조 위치를 만들어서 다른 값(6)을 참조함

함수

lambda expression

익명함수(anonymous function) : 이름 없이 한번만 사용하고 말거나 다른 함수의 인수로 사용하는 함수

람다식의 활용>>

# 1. 변수로 참조하기
add = lambda x, y : x + y
print(add(4,5))
# 2. 인수로 람다식 넘기기
num = [1, 2, 3]
square = list(map(lambda x : x**2, num))
print(square)

코드 구현 노하우

조기 반환 Early Return

코드 실행 과정이 함수 끝까지 도달하기 전에 반환하는 기법

def total_price(quantity, price):
    total = quantity * price
    if total > 100:
        return total * 0.9 # 조기 반환
    return total

보호 구문 Guard Clauses

본격 로직을 진행하기 전에 예외처리 코드를 추가하는 기법

def calculate_average(numbers):
    if numbers is None:
        return None
    if not isinstance(numbers, list):
        return None
    if len(numbers) == 0:
        return None

    total = sum(numbers)
    avg = total / len(numbers)
    return avg

합성함수 Composite method

2개 이상의 함수를 활용하여 추가로 함수를 만드는 기법 보통 합성함수는 람다식을 활용함

def add_three(x):
    return x + 3

def square(x):
    return x * x

composed_function = lambda x: square(add_three(x))
print(composed_function(3))

컴퓨터가 초당 연산할 수 있는 최대 횟수는 1억(100,000,000)번

시간복잡도는 연산의 수를 세어서 연산을 몇 번 하느냐를 통해 대략적으로 계산할 수 있다

여러가지 방법이 있지만 가장 일반적으로 Big-O 방법을 사용한다

Python에서 기본 산술 연산들은 O(1)의 시간복잡도를 가짐

예시를 통해 감을 잡아보자면

1) 길이가 n인 list를 처음부터 끝까지 한번씩 출력 : O(1)*n=O(n)

2) 별찍기 문제 - 주어진 숫자 n에 대해 별을 1부터 n개까지 늘려가며 출력한다 : 출력 한 번이 하나의 연산이기 때문에 1 + 2 + ... + n = n(n+1)/2 즉, O(n^2)

3) 박테리아 수명 문제 - 해마다 반씩 세포가 죽을 때 언제 죽을지 계산 : 초기 박테리아 수 = n K년 후 박테리아 수 = n/(2^K) 소멸할 때의 K값 > log_2(n) 결국 log_2(n)을 계산해야 하는데 이때 n을 표현하기 위한 비트 크기에 대한 시간 복잡도가 고려됨. log 연산 자체는 O(1). 때문에 입력을 표현하기 위한(2bit) 복잡도가 log(n)

개인적인 판단이 개입할 여지가 없는 엄격히 규정된 시스템을 사용하는 것을 기계적 트레이더 개인적인 판단이 개입할 여지가 많은 시스템을 사용하는 것을 재량적 트레이더 라고 한다

어떤 트레이더가 될 지는 결국 자신의 성향에 따라 달라지지만 둘다 장단점이 있기 때문에 결국 적절히 조합하여 사용하여야 한다

시스템 트레이딩

시스템을 활용해 돈을 매매하기 전에 당연하게 시스템을 검증해보아야 한다

어떻게?

1. Backtest - 시스템의 규칙을 과거 데이터에 적용
2. Forwardtest - 실제 돈으로 포지션을 소규모 매매하는 것 보통 백테스트부터 시작하고 결과가 좋으면 포워드 테스트로 넘어갔다가 포워드테스트 결과도 좋다면 서서히 포지션 규모를 늘리는 방법으로 진행한다

백테스트

컴퓨터로 소프트웨어를 사용할 수 있지만 결국 실제 트레이딩으로 넘어가는 테스트 방법은 수동검증

수동검증

한번에 하루씩 과거 데이터를 검토하여 그날의 매매 신호를 꼼꼼히 기록한다 이를 매일매일의 기록으로 최소 2년동안의 일일 주가과 거래량 데이터를 통해 반복한다 페이지 맨 위에 시스템 규칙을 적고 날짜, 주가, 신호를 기입하는 칸을 만든다 이렇게 하면 자동 시스템과 다르게 의사결정 능력이 크게 향상될 수 있다

모의 트레이딩

매수, 매도 결정을 기록하고 실제 트레이딩처럼 결과를 추적하되 돈을 걸지 않는 것

모의 트레이딩을 할 때는

• 감정에 치우치지 않고 좋은 판단을 내리기 쉽고
• 실제 트레이딩과 달리 주문이 완벽하게 체결되며 (체결오차 없음)
• 부담없이 어려워 보이는 기회도 잘 잡기 때문에 실제보다 성과가 좋은 편이다

때문에 모의 트레이딩과 실제 트레이딩이 크게 다르기 때문에 모의트레이딩으로 연습하는 것은 큰 도움이 되지 않는다 단지, 모의 트레이딩은 시스템과 함께 나의 자제력을 검증하는 목적으로 사용해야한다

🌟모든 트레이딩의 세가지 요건🌟

1. 트레이딩 설정 어떤 트레이딩이든 3가지 수치 (진입, 목표, 손실제한)을 기입하라 무조건 잠재 위험/ 보상 비율은 2대 1보다 좋아야 한다

2. 위험관리 어느 정도 위험을 감수할지 미리 결정하라

3. 전략 모든 트레이딩은 구체적인 시스템 또는 전략을 토데로 해야한다 반드시 트레이딩 계획과 전략을 먼저 결정하고 이에 맞을 때만 진입하라

대표적인 시스템 Proposal

삼중 스크린 매매 시스템

두 번의 검증장치(스크리닝)을 거쳐 매매하는 기법 스크린 -> 스크리닝 -> 스크리닝 3단계 테스트를 모두 통과하면 성공할 확률이 훨씬 높아진다

시장은 단 하나의 지표로 분석하기에는 너무 복잡하고 지표들은 동일한 시장에서 상반된 신호를 보내기도 한다

예를 들어 추세추종지표는 추세를 따라가기 때문에 상승 추세에 매수 신호를 보내는데 전환점을 식별하는데 유리한 오실레이터는 과매수 상태가 돼 매도 신호를 보낼 수 있다

추세 추종 지표는 시장이 움직일때는 수익을 볼 수 있는 지표지만 박스권일 때는 속임수 신호가 되고, 오실레이터는 시장이 박스권에 있을 때는 수익을 주지만 시장이 추세를 보이면 위험하다.

사람은 결국 자기가 하고 싶은 매매에 지표를 맞추기 일수라서 지표를 사용하는 것에 주의해야한다

또 다른 예시로 시간 단위 선택에도 추세가 달라진다. 일간 차트에서는 상승추세가 주간 차트에서는 하락일 수 있는데 어떤 시간 단위를 기준으로 할 것인가?

첫 번째 스크린: 시장의 조수 판단

내가 주로 트레이딩 하고자 하는 시간단위를 선택한다(ex-며칠) 그 시간 단위(ex-일간)가 중기(파도)가 된다. 그보다 작은 단위(ex-분간)는 단기(잔물결)이 되고 큰 단위(ex-주간)은 장기(조수)가 된다

삼중 스크린은 트레이딩하고자 하는 차트의 시간 단위보다 한 단계 더 큰 단위의 스케일을 분석하는 것에서 시작된다 => 조수🌊

장기 차트를 통해 황소🐮가 될지 곰🐻이 될지 정한다 그리고 나서 중간 스케일로 가서 어디에서 진입하고 어디에 손실제한을 설정할지 전술을 짠다

트레이더에겐 매수, 매도, 관망 3가지 선택지가 있다. 첫 번째 스크린은 이 중 하나를 걸러주는 역할을 한다 ex - 상승 추세가 나타날 때는 매수 또는 관망만 허락한다 하락 추세가 나타날 때는 매도 또는 관망만 허락한다

임펄스 시스템을 첫 번째 스크린으로 활용하는 것을 추천한다

(연습해보자.)

주간 MACD 히스토그램을 삼중 스크린의 첫번째 스크린으로 활용 일단 무조건 주간만 본다 (일간? 그런거 있다고 생각 하지도 마!)

주간 MACD 히스토그램의 A에서 최상의 매수 신호 켜짐 히스토그램 최근 2개의 기울기가 상승 전환할때 매수신호가 켜지는데 A, C, E에서 매수신호가 B, D에서 매도신호가 떴음 그럼 A, C, E에서는 매수 또는 관망 B, D에서는 매도 또는 관망 그리고 복습하자면 A와 E가 C보다 더 좋은 매수신호!

두 번째 스크린: 시장의 조수에 역행하는 파도!

주간 차트에서 이탈하는 일간 차트의 움직임을 식별한다 어떻게? 이 때 오실레이터를 사용한다 첫 번째 스크린을 통해 이미 시장의 장기 추세와 반대되는 방향의 매매는 필터링 했기 때문에 오실레이터를 통해 가격이 하락했을 때 매수신호 가격이 상승했을 때 매도 신호를 보낸다

일간 차트에 오실레이터를 적용한다 강도 지수, RSI, 엘더-레이, 스토캐스틱 같은 오실레이터도 괜찮다

(연습해보자.) 일일 강도 지수를 두번째 스크린으로 활용 (나중에 연습해보자)

세 번째 스크린: 진입 기법

세 번째 스크린은 진입 기법으로 보다 자유롭다 여러 방법이 있지만 하루종일 실시간 데이터를 들여다 볼 수 없는 나에게는 크게 적용할 수 있는 방법은 아닌 것 같은데 책의 저자가 제시하는 방법 중 "평균 지수이동평균 관통"이 오전에 주문하는 경우 대체할 수 있다고 한다

평균 지수이동평균 관통 주가가 상승하는 동안에도 되돌림이 발생하는데 이 되돌림이 빠른 지수이동평균 아래 얼마나 하락하는지 측정해본다 그림의 일간 차트에서 지난 4~6주간의 일간차트를 기준으로

1. 주가가 A, B, C, D 네 차례 빠른 지수이동평균(13일-ⓛ) 아래로 하락했고
2. 평균 하락 관통값은 9.60달러이다
3. 오른쪽 끝(오늘)의 지수이동평균은 1,266달러이고
4. 전날의 지수이동평균 대비 증감량을 통해 내일의 지수이동평균을 예측한다(extrapolation)
5. 거기서 최근 하락 관통값의 평균을 뺀 가격 수준에서 매수 주문을 낸다
6. 이렇게 싸게 살 수 있는 기회를 잡을 때 까지 매일 계산해서 매수 주문을 낸다

이 외에 상향 돌파에 들어갈 수 있는 방법도 있는데 나한테는 좀 어려울 것 같으니까 스킵하고 나중에 공부토록 하자

삼중 스크린 매매 시스템은 손실 제한을 설정할 수 있는 폭이 상당히 좁다 오로지 시장의 조수 방향에 따라 트레이딩 하는 기법이기 때문에 수익이 빨리 나지 않으면 재빨리 도망가야한다 흐름을 못 탔다 싶으면 빠져나와야한다!!

임펄스 시스템

트레이딩을 계획할 때, 위험과 보상을 비교할 수 있도록 진입수준, 수익 목표, 손실제한을 정하고 시작해야 한다

잠재 보상이 위험보다 최소한 2배는 커야한다 1달러 벌자고 1달러 위험을 감수하는 멍청이가 될 순 없다

수익 목표

이동평균, 채널, 지지/저항 수준 3가지가 보통 현실적인 수익목표가 된다

이동평균

장기 이동 평균과 단기 이동 평균 사이에 가치가 존재하기 때문에 가치보다 낮은 가격에 사서 가치와 같을때 차익을 실현하면 하나의 트레이딩 시스템이 된다 참고

채널

이동평균선과 나란히 두개의 평행선을 그리되, 이동평균선 위와 아래로 하나씩 그리면 하나의 채널을 구축할 수 있다

채널은 정상적인 주가 움직임과 비정상적인 주가 움직임을 판가름하는 경계선 역할을 한다 How? 주가가 채널 안에 있으면 정상, 주가가 채널 바깥이면 비정상

채널선 그리기

느린 이동평균을 채널의 중심으로 잡는다 채널의 폭은 계수를 어떻게 설정하느냐에 따라 달라진다

상단 채널선 = 지수이동평균 x ( 1 + 채널계수 ) 하단 채널선 = 지수이동평균 x ( 1 - 채널계수 )

처음 채널을 구축할 때는 지수이동평균의 3%나 5%로 잡고 채널안에 최근 지난 100개 바에 해당하는 전체 주가 데이터의 95%가 포함되도록 계수를 계속 조정한다 즉, 변동성이 크면 폭이 더 넓은 채널이 필요하고 변동성이 작으면 폭이 더 좁은 채널이 필요하다

채널선을 그릴때 어플을 사용한다면 Envelope를 찾아서 그리면 된다

지지/저항 수준

참고

1. 손실제한
2. 트레이딩 규모 관리

저번에 손실제한을 거는 방법에 대해 공부했으니 오늘은 트레이딩 규모에 따른 위험관리에 대해 알아보자

트레이딩 규모 관리?

손실제한이면 충분한거 아니야?

NO! 또 하나의 명심할 점은 계좌 규모와 트레이딩 규모를 맞춰야 한다는 것!

2% 규칙

1회 트레이딩으로 부담하는 위험이 계좌의 2퍼센트를 넘지 않도록 한다

계좌에 5000만원이 있다면 한번의 트레이딩에 감수할 수 있는 최대 위험은 100만원으로 제한된다

즉, 50000.02=100(만원)=*진입지점-손실제한 사이의 거리**

다음 트레이딩을 할 때는 몇 주를 매수할거야? 초보는 100주! 200주! 아무숫자나 대충 선택하지 (찔림)

이제는 2% 규칙을 통해 내가 진입할 지점과 손실제한 사이의 거리를 계산해 최대 몇 주 까지 살 수 있을지 정할 수 있다

6% 규칙

이번 트레이딩을 할만한 가용위험이 충분한가?

한달 동안 트레이딩으로 계좌가 입을 수 있는 총 손실이 계좌의 6%를 넘지 않도록 한다

계좌에서 이번달 손실을 계산하여 모두 더한다 그리고 그 손실에 현재 오픈 포지션의 위험도 모두 더한다 이 때 더한 총액이 월초 계좌 자금의 6%에 도달하면 월말까지, 또는 오픈 포지션의 위험을 줄여 손실제한을 올릴 수 있을 때 까지 다른 트레이딩이 금지된다

그래서 찾아봤습니다 손실제한 주문을 넣는 방법을!

stop-loss 주문 방법

내가 주로 트레이딩하고자 하는 계좌는 각각 삼성증권과 나무증권이어서 두 증권사에서 stop-loss를 주문하는 법을 찾아보았다

또 stop-loss는 결국 내가 지정한 가격에 증권사 시스템이 알아서 매매를 하도록 하는 거라서 계좌 등록 및 사용자 동의가 필요했다

즉, 단순히 지정가 주문이 아닌 다른 방법이 있다는 뜻!

삼성증권

삼성증권에서는 자동주문 을 통해 손실제한주문을 넣을 수 있었다

해외주식>해외주식자동주문>매도/매수 주문

들어가면 이것처럼

✅ 가격지정 : ( )USD 이하 확인 후 매도 ✅ 비율지정 : ( )USD 대비 ( )% 상승/하락 시 매도 ✅ 트레일링 : ( )USD 대비 ( )% 상승 후 직전 고점 대비 ( )% 하락 시 매도

를 설정해서 본인의 손실제한 규칙에 따라 매도/매수가 가능하다!

나무증권

나무증권에서는 시세포착주문을 통해 손실제한주문을 넣을 수 있다

해외주식>현재가/주문>해외주식 시세포착주문

여기에 들어가면 내가 가지고 있는 계좌의 보유주식 List가 나오고(매도감시의 경우)

각 계좌에 대해 조건등록과 타종목 감시가 가능하다

조건등록

✅ 이익실현 : 이익률/현재가 ( )%/USD 이상 ✅ 손실제한 : 손실률/현재가 ( )%/USD 이상 ✅ Trailing : 이익률/현재가 ( )%/USD 상승하여 목표금액이 [ ]이상이었다가 고점 대비 ( )% 하락시 주문 실행

타종목 감시

나무증권에는 다른 종목이나 지수에 따라 매매를 할 시점을 잡을 수 있도록 자동화 하는 설정도 있었는데 그게 바로 타종목 감시

✅[내가 선정한 타종목]의 목표가 ( )PT 이하/이상일 때

손실 제한 설정

들어갈 때 안전바를 설치하자

안전지대 손실제한 (SafeZone Stop)

주가를 signal + noise로 보았을 때, noise가 일어난 수준보다 멀리 손실제한을 두는 방법

예를 들면 22일 지수이동평균을 하향 돌파한 지점을 모두 찾아서 돌파값을 평균내면 상승추세동안 생긴 평균 하향 돌파값을 산출할 수 있고 이게 노이즈의 평균 수준이라고 볼 수 있다 그럼 이 평균 수준에서 떨어진 만큼 (예를 들면 2배)에 손실 제한을 둔다

닉의 손실제한 (Nic's stop)

최신의 저점에서 가장 낮은 저점은 뻔한 수준의 손실제한이다. 절대 뻔한 수준에는 손실제한을 설정하지 말라 그래서 닉이 제안한 손실제한은 가장 낮은 저점보다 두번째로 낮은 곳을 손실제한으로 설정한다

또한 같은 이유로 어림수에 손실제한을 걸지말고 애매한 숫자에 걸도록 하자 예를 들면 80달러에 진입했다면 78달러가 아니라 77.94달러에 손실제한을 설정해라

평균 실제 거래 범위 (ATR) 손실제한

이 내용은 내가 이해하기에는 조금 어려워서 좀더 공부가 필요해 보인다

수익이 나기 시작하면 수익을 보호하자

수익이 나는 주식이 손실이 나도록 두지 않기 위한 손실제한 주문도 있다 <--이번 하락에 뼈저리게 배운 부분. 급락엔 브레이크가 없어요~

평가이익의 얼마만큼을 보호하기로 정하고 손실제한을 정한다

but 문제는 여러개의 다양한 지표가 모순되는 경우가 생긴다는 것이다

따라서 다양한 지표군에서 소수의 지표를 선정해 서로 조합하는 법을 익혀야 한다

지표는 시가, 종가, 저가, 종가, 거래량. 이 5가지 데이터를 토대로 한다

지표를 산출하는 근원은 주가이다. 근원이 같기 때문에 지표를 열개, 백개 쓴다고 더 심도있는 분석을 얻는 것은 아니다

하지만 각 지표가 목표로 하는 것이 다르기 때문에 여러 지표를 조합해서 봐야 한다

어떤 때는 신호가 아주 명확하지만 어떤 때는 아주 모호하다 지표가 불을 보듯 명확할 때만 진입하라 익숙한 지표를 보고있는데 메시지를 이해할 수 없다면 혼조세를 보이고 있을 확률이 높다 지표의 신호가 분명치 않다면 신호를 조작하거나 다른 지표를 더 추가하지 말고 다른 종목을 찾아나서라. 누가 그거 사라고 협박 안한다!

지표는 추세추종지표, 오실레이터, 기타 군소 지표 세부류로 나눌 수 있다

추세추종지표

종류 : 이동평균, MACD선, 방향성 시스템, 거래량균형(OBV), 매집/분산(A/D) 특징 : 추세가 반전된 후 방향을 선회하므로 동행 또는 후행 지표

이동평균

• 단순이동평균
• 지수이동평균
• 가중이동평균

  단순이동평균 SMA

  $SMA={P_1+P_2+...+P_N\over N}$ 이 때 $N$ : 이동 평균 산출 기간

가장 최근의 주가를 반영하면서 가장 오래된 주가가 떨어져 나가기 때문에 현재 시황과 관련없이 이동평균 값이 크게 출렁일 수 있다

지수이동평균 EMA

$EMA=P_{today}k+EMA_{yesterday}(1-k)$ 이 때, $k = 2/(N+1)$

기울기가 상승하면 강세장, 하락하면 약세장으로 기울기를 늘 주시해야 한다 산출 기간이 짧을 수록 주가 변화에 민감하게 반응하기 때문에, 속임수신호(whipsaw)를 많이 만들어 낸다 그래서 이 산출기간을 어떻게 잡을지에 대한 의견이 분분한데 Tip은 시장 사이클에 맞춰 지배적인 시장 사이클의 절반으로 잡아야 한다 (시장 사이클이 22일이라면 11일 이동평균을 사용) ㅎㅎ근데 시장사이클도 변함 장기투자자는 200일, 대다수 트레이더는 10~30일 이동평균을 사용한다

신호를 얻으려고 변수를 만지작 거리면 객관성을 잃는다. 하나로 고정!

가중이동평균 WMA

각자 중요하다고 생각하는 날에 가중치를 부여 : > 아주복잡하므로 숙련자가 아니라면 지수이동평균을 활용!

💡이동평균을 이용한 매매 기법

1. 추세추종 상승하면 진입할 기회를 찾는다. 주가가 이동평균선 부근에서 일시하락(조정)할 때 매수하라. 가장 최근의 단기저점 아래 손실 제한 주문을 설정하고 내가 산 시점보다 종가가 높이 형성되지 마자 손실제한을 손익분기점으로 옮긴다

2. 거래량 지표의 이동평균 거래량이 5일 이동평균선 아래로 떨어지면 단기 추세에 군중이 흥미를 잃었으므로 시장이 반전될 가능성이 있고, 거래량이 이동평균선을 돌파하면 군중이 시장에 관심을 보이고 있다는 의미로 주가 추세가 확증되었다고 받아들인다

3. 이중 지수 이동 평균 장기 지수이동평균은 가치에 대한 장기 합의, 단기 지수이동평균은 가치에 대한 단기합의 이 비율은 2대1로 유지한다(13주 vs. 26주, 11일 vs. 22일) 두 지수이동평균 사이의 공간을 가치공간이라고 부른다(가치는 두 이동평균 사이에 거주) 단기 이동평균은 가치구간의 경계를 정하고, 장기 이동평균은 추세를 식별하는데 유용하다. 매수와 공매도 시점은 가치구간으로 되돌림할 때이다

하지만 내가 가져온 Tiger200을 보면 알겠지만 쉽지 않다 하나의 지표만으로 트레이딩에 성공할 수 없다. 여러가지 지표로 트레이딩 시스템을 구축해야한다. 명심!

MACD 지표

MACD선 + 시그널선 ※ MACD = Moving Average Convergence and Divergence

1. 종가의 12일 지수이동평균을 구한다
2. 종가의 26일 지수이동평균을 구한다
3. 12일 지수이동평균 - 26일 지수이동평균 값을 그린 선 = MACD선
4. MACD선의 9일 지수 이동 평균 = 시그널선

MACD선 = 빠르다 시그널선 = 느리다

💡MACD선을 이용한 매매 기법

단순이동평균을 토대로 하는 시스템보다 매매신호와 속임수 신호를 적게 보낸다 빠른 MACD선이 느린 시그널선을 상향 돌파하면, 황소들의 시장 장악 => 롱포지션

빠른 MACD선이 느린 시그널선을 하향 돌파하면 곰들의 시장 장악 => 숏포지션 일봉으로도 볼 수 있음

오실레이터

상승하면 진입할 기회를 찾는다. 주가가 이동평균선 부근에서 일시하락(조정)할 때 매수하라종류 : MACD 히스토그램, 강도지수, 스토캐스틱, 변화율(ROC), 모멘텀, 상대강도지수(RSI), 엘더-레이, 윌리엄스%R 특징 : 주가 전환에 앞서기 때문에 선행지표 또는 동행지표로 전환점을 식별하는데 유리하다

MACD 히스토그램

황소와 곰 중 어느쪽이 시장을 장악하고 있는지도 알수 있을 뿐더러 어느 세력이 약해지고 있는지 강해지고 있는지 볼 수 있음

MACD 히스토그램 = MACD선 - 시그널선

MACD 히스토그램의 기울기를 통해 어느쪽이 시장 주도 세력인지 판별할 수 있다 MACD 히스토그램의 기울기가 상승하면 황소가 점점 세력을 키우고 있다는 의미고 MACD 히스토그램의 기울기가 하락하면 곰이 점점 세력을 키우고 있다는 의미이다

• MACD 히스토그램의 기울기와 주가가 같은 방향으로 움직이면 주가 추세가 안정적으로 볼 수 있고, 반대로라면 강도와 안정성에 의심을 제기해야 한다
• MACD 히스토그램의 0선 위아래 여부보다 기울기가 더 중요하고 기울기 방향대로 트레이딩 하라.

💡MACD Histogram을 이용한 매매 기법

1. (흔한 신호) 히스토그램의 기울기 히스토그램이 하락을 멈추고 이전 막대보다 올라가면 매수 히스토그램이 상승을 멈추고 이전 막대보다 낮아지면 매도 ※ 일간차트 보다는 주간차트에서 의미를 갖는다

2. (드물지만 강력한 신호) MACD 히스토그램과 다이버전스 모든 천장이나 바닥마다 다이버전스가 발생하는 것은 아니지만, 주요 반전의 강력한 신호가 된다.

Divergence 이미지 출처

• 강세 Divergence A에서 주식이 급강하 하고, MACD Histogram도 신저점을 기록하며 계속 떨어질 것 처럼 보인다 그러다가 B에서 주식이 반등하며 주가가 가치구간 사이를 찍고, 다시 하락하며 신저점을 기록하지만 MACD Histogram에서는 이전의 저점(A)에 비해 높은 저점(C)를 기록한다. 그리고 MACD Histogram이 상승하면서 강세 Divergence를 완성한다 => 강력한 매수신호

• 약세 Divergence A에서 주식이 계속해서 오르며 신고점을 찍고, 잠깐 B에서 주식이 떨어지며 주가가 가치 구간을 찍고, C에서 다시 상승하여 신고점을 찍지만 MACD Histogram에서는 이전만큼의 상승을 기록하지 못하고 Divergence를 완성함. => 강력한 매도신호

바스커빌 가의 사냥개 신뢰할 만한 차트나 지표 패턴이 보이지만 주가가 예상대로 움직이지 않고 반대로 움직일때! -> 응당 있어야할 행위가 없었다 이것 자체가 신호가 된다

즉, 새롭게 나타난 강력한 추세에 발맞춰야 할때 라는 의미로 약세 Divergence가 무효화되면 롱포지션을(매수포지션) 강세 Divergence가 무효화 되면 숏포지션을(매도포지션) 취한다.

스토캐스틱

종가와 최근의 '고가-저가' 거래 범위의 관계를 추적

산출방법

1. raw stochastic (%K)를 구함 : %$K={C_{tod}-L_n \over H_n - L_n}*100$ $C_{tod}$ : 오늘의 종가, $L_n$ : 산출 기간동안의 최저가격 사람마다 산출 기간을 달리하지만 표준은 5일

2. %D를 구함 : %$D={(C_{tod}-L_{n})의\ 3일\ 총합\over (H_n-L_n)의 \ 3일\ 총합}*100$ %K의 평활화

빠른 스토캐스틱 : %K와 %D 두 선으로 구성됨 느린 스토캐스틱 : %D를 %K로 취급하고 이를 다시 평활화 하여 %D를 만든다 박스권 안에서는 현금인출기라고 말할 수 있을 수준으로 잘 맞지만 박스에서 벗어나 추세가 시작되면 무조건 손실이 나기 때문에 손실제한을 반드시 정해야 한다

스토캐스틱은 황소나 곰의 역량이 강해지는 시기와 약해지는 시기를 보여주기 때문에 누가 이길지 판단할 수 있다

Divergence

스토캐스틱과 가격 사이에 divergence가 발생할 때 가장 강력한 매매 신호

과매수와 과매도

상단 기준선 위로 올라오면 과매수 상태 하단 기준선 밑으로 떨어지면 과매도 상태라는 의미로 주가가 너무 높고 주가가 너무 낮아 반대 경향이 임박했다는 신호 이는 박스권에서는 적중하지만 시장이 뚜렷한 추세를 가지고 있을 때는 주의를 보여야 한다 그러므로 장기 추세추종지표를 함께 활용하는 것이 좋다

주간차트에서 상승 추세가 확인되면 일일 스토캐스틱 선이 하단 기준선 아래로 떨어질 때 까지 기다림. 그리고 하단 기준선 아래로 떨어지면 선들의 교차나 상승전환을 기다리지 말고 최근 고점을 터치했을 때 시장가 매수주문을 넣어라(교차할 때는 이미 늦는 경우가 왕왕있다)

군소 지표

종류 : 신고점/신저점(NH/NL) 지수, 풋콜 비율, 강세합의 지수, 트레이더 동향(COT) 보고서 특징 : 강세/약세의 정도가 어느정도인지 나타내는 선행 또는 동행지표.

트레이딩은 마이너스섬 게임이다. 늘 수수료와 체결오차 문제가 내 돈을 야금야금 갉아먹고 있는, 손실을 보고 들어가는 게임이라는 것을 잊지말자

개인 심리

• 트레이더가 트레이딩 하는 것은 알콜중독이나 도박중독자와 다를 바가 없어서 알코올 중독자 모임 (AA모임)에 참석하는 것이 많은 Insight를 줄 수 있다 알코올=손실, 알코올 중독자 = 패자 이라고 바꿔서 이야기를 들으면 자신의 이야기를 많이 들을 수 있다. 우리 모두 알코올 보다 연약하고 늘 휘둘린다.
• 금융 시장의 지도자는 세가지 부류로 나눌 수 있다. (1) 시장 사이클을 주창하는 지도자, (2) 마술 같은 투자기법을 주창하는 지도자, (3) 죽은 지도자. 누군가 날 부자로 만들어 줄것이라는 환상에서 벗어나야 한다
• 시장의 행위가 종잡을 수 없는 것처럼 보인다면 그건 내 행위가 종잡을 수 없고 통제 불능이기 때문이다.

침착한 전문가가 되기위한 원칙

• 시장에서 오래 살아남겠다고 다짐하라. 앞으로 20년은 트레이더로 남아있겠다고
• 가능한 많이 배워라. 전문가들이 쓴 책을 읽고 그들의 말에 귀를 기울이되 모든 말에 의문을 품어라
• 탐욕에 휘둘려 성급하게 뛰어들지 마라. 시간을 갖고 천천히 배워라. 앞으로 몇 달, 몇년 뒤에도 시장은 많은 기회를 품은채 존재할테니
• 시장을 분석하는 기법을 개발하라. A가 일어나면 B가 뒤따를 확률이 높다는 식으로 자신만의 기법을 만들어라. 강세장/약세장 전환기를 구별하는 도구를 보유하고 때에 따라 트레이딩 하는 다양한 도구가 있어야 한다
• 자금 관리 계획을 세워라. 제1목표가 오래 살아남는것, 제2목표는 자본을 구준히 늘리는 것, 제3목표는 높은 수익을 올리는 것이다. 이 순서가 바뀌면 안된다
• 어떤 전략과 시스템을 적용하든 나 자신이 가장 취약하다는 것을 받아들여라
• 승자와 패자는 생각하고 느끼는 방식이 다르다. 시장에서 이기고 싶다면 성격까지 환골탈태하고 성장하라

집단 심리

• 사람은 누구나 다른 사람들 처럼 행동하고 싶어하는 강한 욕구를 가지고 있다. 군중의 힘은 강력하다. 함께 달릴 필요는 없지만 군중과 맞서지 말아라. (추세가 상승곡선이라면 매수하거나 관망해야하지 무리하게 공매도 하지 말아라)

• 우리보다 한 발 앞서 정보를 입수하는 집단이 최소 하나 이상은 있다

• 기관투자자가 시장에서 개인투자자보다 훨씬 유리하다(저렴한 수수료, 내부 정보, 자본금의 규모, 심리적 안정감)

• 하지만 개인 투자자는 트레이딩을 멈출 수 있지만 기관은 트레이딩을 멈출 수 없다. 개인 투자자는 자신이 생각하는 최적의 기회가 올 때 까지 언제까지나 기다릴 수 있다.

• 트레이딩 SW

  • Tool Box : data를 늘어놓고 차트를 그리고 지표를 설정하거나 변수를 바꾸고 트레이딩 시스템을 검증한다. 각자 필요에 따라 최적화 하기 쉽다
  • Black Box : 매도와 매수 타이밍만 알려준다. 봉이 김선달이다.
  • Gray Box : 중간으로 보통 유명한 시장 전문가에 의해 출시되는데, 구매자가 변수를 조정할 수 있도록 시스템의 대략적인 논리를 공개한다

• 대다수의 소식지는 내부자가 된 듯한 착각을 판다. 소식지는 실적 날조가 가능하다. 교육용으로만 활용하라

• 인간은 미칠 땐 집단으로 미치고 돌아올 때는 한 사람씩 천천히 돌아온다 - 맥케이

• 집단과 거리를 두고 독립적으로 사고하는 자만이 성공할 수 있다

• 하지만 인간은 불확실성이 클수록 무리에 합류하고자 하는 본능을 가진 존재이다. 트레이딩 계획에서 합리적으로 판단해도 시장에 진입하는 순간 군중에 휩쓸린다. 자신보다 지도자를 더 믿을 때, 그리고 자신의 트레이딩 계획을 지키지 않을 때 독립성을 잃었다고 볼 수 있다. 평정심을 되찾을 수 없다면 차라리 정리하고 쉬는게 낫다

• 트레이딩 시스템과 자금 관리 규칙을 적어두고 그대로 지켜라. 트레이딩에 진입하기 '전에'만든 합리적이고 개인적인 판단을 고수해라

• 집단을 따라간다면 군중의 지혜를 따라라. 그러니까 똑똑한 집단을 만들어라. 이런 집단은 개개인이 투자방향과 주식 선정을 혼자 내리고 모든걸 결정 한 후 공유를 시작한다

• 가격의 상승과 하락은 사람들의 심리에 달려있다. 탐욕과 두려움에 따라 가격이 상승과 하락이 결정된다.

• 집단은 원초적이므로 행동을 예측하기 쉽다. 시장을 분석하는 것은 집단행동을 분석하는 것이다.

전통적인 차트 분석법

전통적으로 차트의 패턴을 분석하는 방법이 있다. 그 부분을 살펴보자 하지만 주의할 점. 전통 차트의 가장 큰 문제는 '원하는 대로' 보게된 다는 것이다.

주가란 모든 시장 참여자가 순간적으로 합의한 가치가 행동으로 나타난 것이다

시장과 동떨어진 이론

효율적 시장이론

가격은 이용 가능한 모든 정보를 반영하고 있으므로 누구도 시장 평균 이상의 수익을 올릴 수 없다.

맹점 : 사람들은 알고 있는 대로 행동하지 않는다

랜덤워크

주가 변화는 어떤 규칙도 없이 무작위로 일어난다

맹점 : 사람의 기억은 행동에 영향을 미친다

카오스 이론

시장은 대체로 혼돈 상태이며 우위를 점할 수 있는 시간은 질서가 있을 때 뿐이다

저자의 생각 : 시장은 대체로 혼돈 상태인 것은 맞지만, 혼란을 뚫고 계속해서 질서와 구조가 나타났다고 사라진다. 이건 동떨어진 이론은 아니다 ^-^

자연의 법칙

시장에는 완벽한 질서가 있다.

지지와 저항

지지와 저항이 존재하는 이유는 최고점과 최저점을 인간이 기억하기 때문이다 트레이더 집단이 고통을 느끼고 후회하기 때문에 지지와 저항이 만들어 진다.

지지

하락 추세를 저지하거나 반전시킬 정도로 강력한 매수세가 형성된 주가 수준 하락 추세가 지지 세력과 만나면 반등한다 차트 위에 저점을 두개 이상 연결한 수평선이 그어지면 이것이 바로 지지선이다

저항

상승 추세를 저지하거나 반전 시킬 정도로 강력한 매도세가 형성되고 있는 주가 수준 상승 추세가 저항 세력과 만나면 움직임을 멈추거나 하락 반전한다 차트 위에 고점을 두개 이상 연결한 수평선이 그려지면 그것이 저항선이다

심리 파악하기

주가가 거래 범위를 이탈해 상승하면, 황소는 더 많이 사지 않은 것을 후회하고, 곰은 고통스러워한다 그리고 다음에 가격이 떨어져서 동일한 시점에 도달하면 반드시 황소과 곰 모두 매수하기로 다짐한다 → 지지 영역의 형성

주가가 거래 범위를 이탈해 하락하면, 황소는 괴로워하고 반등을 기다린다. 곰은 더 많이 공매도 하지 못한것을 한스러워한다. 그리고 다음에 가격이 다시 올라서 동일 지점에 닿으면 황소는 매도하고 곰은 더 많이 공매도 한다 → 저항 영역의 형성

그렇기 때문에 황소와 곰이 그 구역에 감정적으로 집착할 수록 지지와 저항의 강도는 세진다.

1. 지지나 저항 영역의 길이; 기간이 길거나 각 영역에 부딪힌 바의 수가 많을수록 강도가 세다
2. 지지나 저항 영역의 높이가 높을 수록 강도는 세다
3. 지지나 저항 영역의 거래량이 많을수록 강도는 세다

주식이 밀집 구간에 머문 일수에 일평균 거래량과 주가를 곱하면 지지나 저항의 강도를 달러로 측정할 수 있다

지지 & 저항을 활용한 매매 기법

다음이시간에

## 추세
추세는 추세선으로 확인하지 않고 지수이동평균을 이용해 주로 확인된다
추세선은 매우 주관적인 지표로 자기 기만에 빠지기 가장 쉬운 도구이다