IT SQUARE

SOLID 원칙

squareyun — Mon, 24 Jun 2024 14:16:20 +0900

SRP 단일 책임 원칙

한 클래스는 하나의 책임만 가져야 한다.
중요한 판단 기준은 변경. 변경이 있을 때 파급효과가 적어야 한다.
객체의 생성과 사용을 분리

클래스 하나에 너무 많은 것을 집어 넣지 말자. 문제가 발생했을 때 유지보수가 편리하게.. (한 변경에서 다른 책임의 변경으로의 연쇄작용은 최악)

OCP 개방 폐쇄 원칙 ✦

소프트웨어 요소는 확장에는 열려있어야 하며, 변경에는 닫혀있어야 한다.
- 확장에 열려있다? 새로운 변경사항이 발생했을 때 유연하게 코드를 추가, 수정
- 변경에 닫혀있다? 객체를 직접 수정하지 않고도 변경사항을 적용
다형성을 활용
- 자동차, 공연 배우 예시를 생각
- 역할과 구현을 분리
문제점
- 구현 객체를 변경하려면 클라이언트 코드를 변경해야 한다.
- 따라서, 객체 생성과 연관 관계를 맺어주는 별도의 조립, 설정자가 필요한데,,
- 이것을 spring이 해결해줌!

APPLE이 이것을 잘함 기능 or 목적에 따라 '잘 쪼개기'

LSP 리스코프 치환 원칙

객체는 프로그램의 정확성을 깨뜨리지 않으면서 하위 타입의 인스턴스로 바꿀 수 있어야 한다.
부모, 자식이라는 계층 관계가 만들어질 때, 부모 객체에 자식 객체를 넣어도 시스템이 문제 없이 돌아가게 만드는 것
하위 클래스는 인터페이스 규약을 잘 지켜서 작성되어야 함
자동차 인터페이스의 악셀 기능은 앞으로 가야하는 원칙이 있음
- 뒤로가게 구현하면 LSP 위반!
- 느리더라도 앞으로 가도록 구현하면 LSP 준수!

"상속을 통한 재사용은 기반 클래스와 서브 클래스 사이에 IS-A 관계가 있을 경우로만 제한 되어야 합니다.
그 외의 경우에는 합성을 이용한 재사용을 해야 합니다."

ISP 인터페이스 분리 원칙

특정 클라이언트를 위한 인터페이스가 많은 것이 범용 인터페이스 하나보다 낫다.
하나의 인터페이스 보다 구체적인 여러 개의 인터페이스를 만들어야 한다.
자동차 인터페이스에 운전, 정비 관련된 것을 운전 인터페이스, 정비 인터페이스로 나누기
‘클라이언트가 편리하게’

DIP 의존 관계 역전 원칙 ✦

추상화에 의존해야지, 구체화에 의존하면 안된다.
역할(Role)에 의존하게 해야한다.
운전자는 자동차의 역할에 집중하고, K3에 대한 디테일은 알 필요가 없다.
클라이언트가 구현 클래스를 직접 선택하는 아래 코드는 DIP를 위반하는 것
변하기 쉬운 것에 의존하던 것을, 추상화된 인터페이스나 상위 클래스를 이용해 변하기 쉬운 것의 변화에 영향을 받지 않게 하는 원칙

MemberRepository m = new MemoryMemberRepository();

참조, 더 읽을 거리

Inflearn - 스프링 핵심 원리 기본편 (김영한)

BOJ 11727. 2×n 타일링 2 - JAVA

squareyun — Sun, 16 Jun 2024 01:21:37 +0900

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

아이디어

DP 문제에 약한 저는 N이 1일 때 부터 6일 때 까지 손수 그려보며 규칙을 찾고자 노력했습니다.

N이 5일 때 `2 + 3` 타일로 나누어 생각했습니다.

그리고 `중간에 겹치는 부분`에 들어갈 2*1 타일과 2*2타일을 생각했습니다.

그렇게 나온 점화식은 `D[i] = 3 * D[i - 2] + 2 * D[i - 3]` 입니다.

다른 분들의 풀이를 보니 1 + 4 타일로 나누어 생각했던데, 점화식은 다르게 나오더라도 결국 같은 접근법입니다.

제출 코드

public class Main {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] D = new int[1001];

		D[1] = 1;
		D[2] = 3;
		D[3] = 5;
		for (int i = 4; i <= n; i++) {
			D[i] = (3 * D[i - 2] + 2 * D[i - 3]) % 10007;
		}
		System.out.println(D[n]);
	}
}

효율성

LRU 알고리즘을 LinkedHashMap을 이용해 구현하기

squareyun — Thu, 25 Apr 2024 21:49:15 +0900

서론

지난 게시글(LRU 알고리즘 파헤치기)로 LRU 알고리즘에 대해 OS와 HW 관점에서 알아봤습니다. 이번에는 Java를 이용해 이것을 구현하려면 어떻게 해야 할지 알아보고자 합니다. Java의 `LinkedHashMap`을 이용하면 편리하게 구현할 수 있습니다.

LinkedHashMap?

Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order).

공식 문서에 따르면 `doubly linked list`를 이용해서 데이터의 삽입 순서를 보장해주는 HashMap이라고 합니다.

A special constructor is provided to create a linked hash map whose order of iteration is the order in which its entries were last accessed, from least-recently accessed to most-recently (access-order). This kind of map is well-suited to building LRU caches.

한편, 특별한 생성자를 제공하는데요. `Access-order`를 보장하는 기능을 제공하는데, 이것이 LRU 캐싱 알고리즘의 핵심 원리입니다. 해당 생성자는 다음과 같은 형태입니다.

LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)

accessOrder: true for access-order, false for insertion-order

구현

/**
 * @Author : yion
 * @Date : 2017. 6. 1.
 * @Description : 가장 오랫동안 사용되지 않은 엔트리(호출되지 않는)를 메모리의 후방에 위치하게 하여 메모리에서 삭제 하는 캐싱 알고리즘
 * LRU (최근사용우선) 와 비슷한 알고리즘으로 LFU(Least Frequently Used : 참조 횟수 기준) 이 있다.
 */
public class LRUCache<K, V> {

	private static final float hashTableLoadFactor = 0.75f;

	private LinkedHashMap<K, V> map;
	private int cacheSize;

	public LRUCache(int cacheSize) {
		this.cacheSize = cacheSize;

		int capacity = (int) Math.ceil(cacheSize / hashTableLoadFactor) + 1;

		map = new LinkedHashMap<K, V>(capacity, hashTableLoadFactor, true) {
			private static final long serialVersionUID = 1;
			@Override protected boolean removeEldestEntry (Map.Entry<K, V> eldest) {
				return size() > LRUCache.this.cacheSize;
			}
		};
	}

	public synchronized V get(K key) {
		return map.get(key);
	}

	public synchronized void put(K key, V value) {
		map.put(key, value);
	}

	public synchronized void clear() {
		map.clear();
	}

	public synchronized int usedEntries() {
		return map.size();
	}

	public synchronized Collection<Map.Entry<K,V>> getAll() {
		return new ArrayList<>(map.entrySet());
	}
}

`cacheSize` : LRU Cache의 최대 크기를 설정합니다. 이 크기를 초과하면 항목을 제거합니다.
`hashTableLoadFactor` : capacity의 몇 퍼센트가 찼을 때 용량을 늘리는 지를 정의합니다.
`capacity` : 실제 초기 용량을 계산합니다. 충분한 초기 용량과 함께 해시 충돌을 최소화합니다.
`removeEldestEntry`는 Victim으로 선정된 item을 제거하기 위해서 오버라이드 되었습니다. 이 메서드는 맵에 새로운 엔트리가 추가될 때마다 호출됩니다.

테스트

public static void main(String[] args) {
    LRUCache<String, String> c = new LRUCache<>(3);

    c.put("1", "one");      // 1
    c.put("2", "two");      // 2 1
    c.put("3", "three");    // 3 2 1
    c.put("4", "four");     // 4 3 2

    if (c.get("2") == null) {
        throw new Error();  // 2 4 3
    }

    c.put("5", "five");     // 5 2 4
    c.put("4", "four");     // 4 5 2

    for (Map.Entry<String, String> e : c.getAll()) {
        System.out.print(e.getKey() + " ");
    }
}

출력 결과 : 2 5 4

if문을 이용해 데이터에 접근했을때의 순서도 보장한다는 사실을 확인할 수 있습니다.

참조

공식문서 - https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/LinkedHashMap.html
도서 - 개발자기술면접노트

코드 - https://github.com/gliderwiki/java8/blob/master/src/main/java/algorithm/lru/LRUCache.java

https://velog.io/@sweet_sumin/LinkedHashMap-%EB%82%B4%EB%B6%80-%EA%B5%AC%EC%A1%B0-%EC%82%B4%ED%8E%B4%EB%B4%A4%EC%96%B4

LRU 알고리즘 파헤치기

squareyun — Thu, 25 Apr 2024 02:03:40 +0900

LRU

페이지 교체 알고리즘 중에 하나로, Least Recently Used의 약자입니다. 즉, 가장 최근에 사용되지 않았던 것을 찾는 알고리즘입니다. 사실 페이지 교체를 위한 Optimal solution(가장 오랫동안 사용되지 않을 것을 선택하는 것)은 이론적인 방법이기 때문에 그것을 위한 근사 방법 중 하나입니다. 페이지 교체와 관련된 내용은 추후에 다뤄보고 여기서는 LRU에 대해서만 이야기하고자 합니다. LRU를 JAVA를 이용해 구현한 내용은 이 게시글을 참조하세요.

LRU page-replacement algorithm

Implementing LRU

LRU 알고리즘을 구현하기 위해서는 다음과 같은 방식이 있습니다.

Counter

가장 단순하게 떠올릴 수 있는 방법 중 하나로, `clock register`를 이용하는 방식입니다. (모든 메모리 참조마다 클락이 증가)
페이지가 참조될 때 마다 페이지 테이블의 시간 필드에 복사합니다.
페이지를 교체할 때 시간 필드에서 가장 작은 값을 찾아 그것을 Victim으로 선정합니다.

하지만, 이 방식은 full Scan 해야 한다는 단점을 가지고 있고, clock register의 오버플로우를 고려해야 합니다.

Stack

페이지 번호를 관리하는 Stack을 `Doubly Linked List`를 이용해 관리하는 방식입니다.
가장 최근에 사용되는 페이지 번호는 Stack의 상단에 위치할 것이기 때문에, OS는 하단에 위치한 페이지 번호를 Victim으로 선정하면 됩니다.
교체에 대한 검색이 없습니다.

이 방식은 업데이트 비용의 단점이 있습니다.

Use of a stack to record the most recent page references.

LRU Approximation Algorithm

사실, 위 방식에 대해 하드웨어 지원을 제공하는 컴퓨터 시스템은 거의 없습니다.

많은 시스템에 있는 `reference bit`를 이용하는 방법이 있습니다.

Reference bit

OS에 의해 모든 비트가 0으로 초기화됩니다.
HW에 의해 페이지가 참조될 때 1로 변경됩니다.
하지만, 순서를 알지 못합니다.
이 bit를 이용해 다음의 알고리즘이 개발되었습니다.

Additional-Reference-Bits Algorithm

페이지 별 `8 bit register`를 이용합니다.
주기적인 간격으로 OS는 각 페이지의 `reference bit`를 고차 비트로 Copy 하고, `shift right`합니다.
가장 작은 숫자가 LRU page입니다.

Second-chance algorithm

`Reference bit`가 0인 페이지를 victim으로 선택합니다.
만약 1이라면 0으로 바꿉니다. 이 방식이 두 번째 기회를 주는 것입니다.
circular queue로 구현할 수 있습니다.

Example of second-chance alghrothim.

Enhanced Second-chance Algorithm

Reference bit 뿐만 아니라, `Modify bit`도 이용합니다.

(0,0) : old, not modified (BEST)
(0,1) : old, but modified
(1,0) : recent, but clean
(1,1) : recent, modified

Victim을 선정하기 위해 circular queue 여러 번 순회해야 할 수도 있습니다.

참조

공룡책
https://velog.io/@huttzza/OS-Ch10-Virtual-Memory-2

LeetCode 39. Combination Sum - JAVA

squareyun — Tue, 23 Apr 2024 00:16:50 +0900

https://leetcode.com/problems/combination-sum/

✅ 체크 포인트

1. ArrayList를 깊은 복사 : ArrayList<>(comb);

2. Backtracking할 때 다음 시작 인덱스를 i 를 해야할까 i + 1 을 해야할까?

제출 코드

class Solution {
    
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        
        List<List<Integer>> answer = new ArrayList<>();
        Arrays.sort(candidates);
        dfs(answer, new ArrayList<>(), candidates, target, 0);
        
        return answer;
    }
    
    private static void dfs(List<List<Integer>> answer, ArrayList<Integer> comb, int[] candidates, int target, int start) {
        
        if (target < 0) return;
        
        if (target == 0) {
            answer.add(new ArrayList<>(comb));
            return;
        }
        
        for (int i=start; i<candidates.length; i++) {
            int cur = candidates[i];
            comb.add(cur);
            dfs(answer, comb, candidates, target - cur, i);
            comb.remove(comb.size() - 1);
        }
    }
}

효율성

[Python] 백준 7662 : 이중 우선순위 큐

squareyun — Wed, 2 Nov 2022 00:06:06 +0900

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

접근 방법

하나의 Priority Queue를 두 가지 기준으로 만들 수는 없으니, 결국 2개의 Priority Queue를 선언해야한다.

Priority Queue의 종류 중 heapq를 사용하여 구현하였다.

heapq는 기본적으로 min-heap으로 구성된다. 따라서, max-heap을 구성하기 위해서는 value에 음수를 취하여 넣고 pop할 때도 음수를 취하여 사용하면 된다.

이 문제의 핵심은 2개의 우선순위 큐를 동기화하는 것이다.

나는 해시 테이블 popHistory를 이용해 동기화를 처리하였다.

<key, value>에서 key는 n를 나타내고, value는 해당 n이 몇 개 존재하는지를 나타낸다.

pop할 때 value를 하나씩 감소한다면, 동기화할 때 0일 경우 해당 n은 무시하도록 처리한다.

코드에 동기화 하는 부분을 주석처리 하였으니 보면서 이해가 되었으면 한다.

코드

# TITLE: 이중 우선순위 수 (https://www.acmicpc.net/problem/7662)
# LEVEL: Gold 4
# TAG: data_structures, priority_queue
# DATE: 20221101
# AUTHOR: squareyun

import heapq
import sys
INF=1e9
input=sys.stdin.readline

t=int(input())
for _ in range(t):
    minheap = []
    maxheap = []
    popHistory = dict()
    k = int(input())
    for _ in range(k):
        op, n = input().split()
        if op == 'I':
            n = int(n)
            heapq.heappush(minheap, n)
            heapq.heappush(maxheap, -n)
            if n in popHistory:
                    popHistory[n] += 1
            else:
                popHistory[n] = 1

        elif op == 'D':
            if n == '1':
                while len(maxheap) != 0:
                    popElement = -heapq.heappop(maxheap)
                    if popHistory[popElement] != 0: #동기화
                        popHistory[popElement] -= 1
                        break

            elif n == '-1':
                while len(minheap) != 0:
                    popElement = heapq.heappop(minheap)
                    if popHistory[popElement] != 0: #동기화
                        popHistory[popElement] -= 1
                        break
    #maxheap 동기화
    answerMax, answerMin = -INF, INF
    while len(maxheap) != 0:
        if popHistory[-maxheap[0]] != 0 :
            answerMax = -maxheap[0]
            break
        else:
            heapq.heappop(maxheap)

    #minheap 동기화
    while len(minheap) != 0:
        if popHistory[minheap[0]] != 0 :
            answerMin = minheap[0]
            break
        else:
            heapq.heappop(minheap)

    if answerMax == -INF or answerMin == INF:
        print('EMPTY')
    else:
        print(f'{answerMax} {answerMin}')

[Python] 구름LEVEL : 개미와 진딧물

squareyun — Tue, 1 Nov 2022 02:03:37 +0900

머리말

최근 구름LEVEL에서 알고리즘 먼데이 챌린지에 참가하고 있다.

해당 챌린지는 매주 월요일에 4문제를 2시간 안에 푸는 코딩 테스트를 진행하고, 그 다음 주에 해설 강의를 제공하는 챌린지이다.

코린이를 위한 프로그램 같지만,, 생각보다 어렵다는 점

스탬프를 얻으면 소소한 간식도 얻을 수 있으니 추천ㅋㅋ

이번 주차의 1번 문제로 개미와 진딧물 문제로 그래프 문제가 나왔다.

접근법

처음에는 BFS 문제인 줄 알고, 개미집 위치를 queue에 모두 넣고 bfs 순회하며 거리를 계산했다.

제출하니 시간초과로 통과하지 못했다.

문제를 단순하게 생각해보자. 입력 값의 범위가 작다! ➡️ 완전 탐색

개미집과 수액의 거리를 완전탐색하며 Manhattan distance 거리를 계산하고, 그 거리가 m 보다 작다면 정답으로 카운트하였다.

코드

n,m=map(int,input().split())
gaemijib=[]
suaek=[]
answer=0
for i in range(n):
	a = list(map(int,input().split()))
	for j in range(n):
		if a[j] == 1:
			gaemijib.append((i,j))
		elif a[j] == 2:
			suaek.append((i,j))

for gx, gy in gaemijib:
	for sx, sy in suaek:
		if abs(gx-sx) + abs(gy-sy) <= m:
			answer += 1
			break
print(answer)

[Python] 백준 3190 : 뱀 (implementation)

squareyun — Fri, 7 Oct 2022 16:40:39 +0900

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

머리말

아, 뱀 게임 로직 짜는 거구나,, 재밌겠다,,
처음에는 뱀의 위치 정보를 어떻게 구현해야 할지 고민을 하다가 큐가 문득 떠올랐다.
자료구조 때 배운 것을 바로 적용할 수 있는 능력을 키우자!

접근 방법

차근차근 해결하면 된다.

맵 정보를 저장하는 graph 리스트에 사과 위치를 2로 저장하였다.
dx, dy 방향 전환을 동, 북, 서, 남 형식으로 저장하여 방향에 맞게 circle로 돌 수 있도록 하였다.
cnt는 게임의 시간 정보를 나타내는 변수로, 이것을 logs 배열에 존재하는지 확인 후 방향 전환을 고려하였다.
뱀의 위치 정보를 저장하는 snake 리스트를 큐(deque)를 사용하여 이동할 때 머리는 push, 꼬리는 popleft 하였다.

코드

from collections import deque

n=int(input())
k=int(input())
graph=[[0] * n for _ in range(n)]
for _ in range(k):
    a,b=map(int,input().split())
    graph[a-1][b-1] = 2 #사과 위치
l=int(input())
logs=[]
for _ in range(l):
    a,b=input().split()
    logs.append([int(a),b])

dx = [0, -1, 0, 1] #동북서남
dy = [1, 0, -1, 0]

def solution():
    cnt = 0
    logIdx = 0
    x, y = 0, 0
    dir = 0
    graph[0][0] = 1
    snake=deque([(0,0)])
    while True:
        cnt += 1
        nx = x + dx[dir]
        ny = y + dy[dir]

        if logIdx < len(logs) and cnt == logs[logIdx][0]:
            if logs[logIdx][1] == 'L':
                dir = (dir + 1) % 4
            else:
                dir = (dir - 1) % 4
            logIdx += 1

        if 0 > nx or nx >= n or 0 > ny or ny >= n: #벽에 부딪힐 때
            return cnt
        elif graph[nx][ny] == 1: #자기자신의 몸과 부딪힐 때
            return cnt
        elif graph[nx][ny] == 2: #사과 만날 때
            graph[nx][ny] = 1
            snake.append((nx,ny))
        else:
            graph[nx][ny] = 1
            snake.append((nx,ny))
            graph[snake[0][0]][snake[0][1]] = 0
            snake.popleft()

        x, y = nx, ny

print(solution())

[Python] 백준 1865 : 웜홀 (Bellman Ford)

squareyun — Tue, 4 Oct 2022 18:23:59 +0900

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

머리말

문제를 보고, 아 negative cycle 찾는 문제이구나 싶었다.

그래프에서 최단 경로를 탐색하는 방법 중 다익스트라와 벨만 포드가 있는데,
다익스트라는 Greedy 알고리즘이기 때문에 반드시 간선들이 non-negative weights을 만족해야 한다.
한편, 벨만 포드는 Dynamic Programming 알고리즘으로 negative weights를 가져도 정상적으로 동작한다!

접근 방법

고급문제해결 수업 자료

edge relaxation을 N-1번 수행한다.
그때 만들어진 distance 배열은 최단 경로이다.
edge relaxation을 N번째 수행했을 때, 더 짧은 경로를 발견한다면 negative weight cycle이 존재한다는 결론!

이슈 사항

1. 시간 초과

문제에서 시작 정점을 주지 않아, 모든 정점에 대하여 시도하였더니 시간 초과가 발생하였다.

결론은 한 정점에서만 시작해도 된다.
벨만 포드 알고리즘에서 한 정점에서부터 다른 정점의 최단 경로를 파악하려고 했기 때문에 방문했던 노드를 다시 방문하지 않으려고 dist[s] != INF라는 조건을 주었다. 하지만 이 문제의 경우 최단 경로를 파악하기 위함이 아닌, just 음수 사이클을 판단하면 된다. (결론적으로 dist 배열은 최단 경로를 저장하는 배열은 아님)

2. 맞왜틀?

처음에 무한대를 float('inf')로 설정하였더니 틀렸다. 대신 int(1e9)로 잡았더니 성공했다.

이것은 dist[s] != INF를 해주지 않았기 때문에 무한대 + 무한대의 계산도 진행된다.
이 과정에서 overflow가 발생할 여지가 충분하므로 잘못된 계산 결과가 나온다.

코드

import sys
input=sys.stdin.readline
INF = int(1e9)

def bellman_ford(start):
    dist = [INF] * (n + 1)
    dist[start] = 0

    # n-1 (vertex개수-1) 번 반복
    for i in range(n):
        for j in range(len(edges)):
            s, e, t = map(int,edges[j])

            if dist[e] > dist[s] + t:
                dist[e] = dist[s] + t
                if i == n-1: # n번째에도 존재한다면 음의 cycle 존재
                    return True
    return False

tc = int(input())
for _ in range(tc):
    n,m,w = map(int,input().split())
    edges=[]
    for _ in range(m):
        s,e,t=map(int,input().split())
        edges.append([s, e, t])
        edges.append([e, s, t])
    for _ in range(w):
        s,e,t=map(int,input().split())
        edges.append([s, e, -t])
    print('YES' if bellman_ford(1) else 'NO')

더 읽을거리

https://backtony.github.io/algorithm/2021-02-13-algorithm-boj-class4-10/

2022년 7월 ~ 8월 월간 일지

squareyun — Thu, 1 Sep 2022 23:00:47 +0900

키워드 일기

7월

# 토익: 다음 달에 있을 토익 공부를 위해 단어, ets 기출 1권을 풀었다. 꾸준히 하자고 다짐했지만 건너뛴 날도 있다 7월 말까지만 해도 LC 귀가 뚫렸다고 생각했었다. ~~(과거형)~~

# 정보처리기사: 대학 동기들이 다 따길래 나도 따라 쳐봤다. 외우는 게 너무 귀찮았지만 필기 합격! 실기 시험은 언제더라

# 제주도 여행(8日-15日): 교회 친구들과 다녀왔는데 스쿠버 다이빙도 처음 해보고,, 이것저것 별거 다해서 행복했다ㅋㅋ 다음에도 모일 수 있겠지?

8월

# 토익: 시험 결과가 나왔는데,, 저번보다 RC는 75점 올랐는데 LC는 35점 떨어졌다 ㅋㅋ. 졸업을 위해서 땄지만 공부한 게 아쉬워서 한 번 더 시험 칠까 고민 중이다. LC 진짜 자신 있었는데 점수 폭망

# 스미싱: 여행 전날 어머니께서 아들 사칭 스미싱을 당해서 가족 모두 멘탈이 안 좋았다. 정말 다행히 금전적 피해는 입지 않았다. (5분 늦었으면 이체당할 뻔했음) 사기 친 ㄱ새끼가 문제긴 하지만 우리 어무이가 당할진 몰랐음 컴공 아들 운다 울어

# 강원도 여행(4日-6日): 가족과 함께 속초, 강릉으로 떠났다. 5-6시간 장거리라 힘들었지만 소중한 추억 한가득 가져왔다. 첫째날에 배부른 상태에서 아바이 순대랑 만석 닭강정 먹었다가 결국 배 터져서 소화제 먹었음;;

# 여름 수련회(11日-13日): 이번에는 대가족 98동기 중 3명밖에 참석 안 해서 외로울 거라 생각했지만, 생각보다 너무 재미있게 보냈다. 친하지 않았던 사람들과 가까워졌고 ~~(내 생각)~~, 수련회 프로그램이 알차서 좋았다. 다음 수련회도 무조건 참석! 근데 나이 너무 많이 먹은 것 같다. 동생들과 친해지고 싶은 나이 먹은 아저씨 느낌

# QT: 수련회가 끝나고 한편으로 마음이 찝찝했다. 불편한 마음을 어떻게 해결할 수 있을지 소중한 친구와 든든한 신앙 선배에게 질문을 했고, 큐티를 시작해보기로 했다. 고민 상담 들어줘서 고마워

# 코로나: 슈퍼 항체인줄 알았던 내가 결국 걸려버렸다~.~ 새벽기도회 간다고 2시간자고 피곤하게 지냈더니 면역력이 약해진 것 같다. 두통과 몸살이 너무 심하다. 특히 머리 진짜 술 왕창 먹고 난 다음날의 느낌이 계속 지속된다. 다행히 어머니가 특별 케어 들어간다고 링거 놔주고,, 궁둥이 주사 놔주고 하셔서 빠르게 회복했던 것 같다.

# 싫어증: 연속되는 휴가와 코로나로 인해 휴식을 많이 했더니 결국 아무것도 하기 싫어증에 걸려버렸다. 가만히 누워 휴대폰만 보다가도 발라드를 들으며 감성에 빠지는 등, 너무 빈둥거려 공부 기록이 좋지 않다. 신경 쓰이는 일들이 생겨 머리 아프지만, 다 잊어 제발~ 9월부터 개강이니 일상을 회복하자-

요약

	총 공부시간	평균 공부시간
7월	103:31:00	04:18:47
8월	59:22:24	02:49:38