├── .github
└── PULL_REQUEST_TEMPLATE.md
├── .gitignore
├── .mergify.yml
├── LICENSE
├── README.md
├── SUMMARY.md
├── answers
├── 1-statistics-math.md
├── 2-machine-learning.md
├── 3-deep-learning.md
├── 4-python.md
├── 5-network.md
├── 6-operating-system.md
├── 7-data-structure.md
├── 8-algorithm.md
├── img
│ ├── 1-statistics-math
│ │ ├── beta-distribution.png
│ │ ├── bias-variance-tradeoff.png
│ │ ├── confidence-level.png
│ │ ├── eigen-vector.jpeg
│ │ ├── eigen-vector.png
│ │ ├── facebook-bayes-rule.png
│ │ ├── facebook-probability.png
│ │ ├── gamma-distribution.png
│ │ ├── gaussian-normal-distribution.png
│ │ ├── hypothesis.png
│ │ ├── probability.png
│ │ ├── sample-size-formula.png
│ │ ├── underfit-right-overfit.png
│ │ └── variance-bias.png
│ ├── 2-machine-learning
│ │ ├── adjusted-r-square.jpg
│ │ ├── categorical-crossentropy.png
│ │ ├── classification-and-linear-regression.png
│ │ ├── confidence.png
│ │ ├── confusion-matrix.png
│ │ ├── curse-of-dimensionality.png
│ │ ├── ensemble.png
│ │ ├── gradient-descent.png
│ │ ├── input-space-and-feature-space.png
│ │ ├── kernel-function.png
│ │ ├── kernel-svm.png
│ │ ├── l1-loss.png
│ │ ├── l1-regularization.png
│ │ ├── l2-loss.png
│ │ ├── l2-regularization.png
│ │ ├── lift.png
│ │ ├── linear-and-logistic-regression.png
│ │ ├── local-minima-global-minima.png
│ │ ├── log-loss.png
│ │ ├── markov-chain.png
│ │ ├── newton.png
│ │ ├── norm.png
│ │ ├── ols.png
│ │ ├── r-square.jpg
│ │ ├── random-forest-bagging.png
│ │ ├── roc-curve.png
│ │ ├── roc.png
│ │ ├── rss.png
│ │ ├── state-transition-diagram.png
│ │ ├── state-transition-probability.png
│ │ ├── stratified-kfold.png
│ │ ├── support.png
│ │ ├── svm.png
│ │ └── xor.png
│ ├── 3-deep-learning
│ │ ├── activation-function.png
│ │ ├── adadelta.png
│ │ ├── adagrad.png
│ │ ├── adam-conclusion.png
│ │ ├── adam.png
│ │ ├── ai.png
│ │ ├── backpropagation.png
│ │ ├── batch-normalization-formula.png
│ │ ├── batch-normalization.png
│ │ ├── bias-example.png
│ │ ├── boltzmann-machine-cell.png
│ │ ├── boltzmann-machine.png
│ │ ├── cost-gradient-optima.jpeg
│ │ ├── cost-gradient.jpeg
│ │ ├── critical-saddle-point-and-local-minima.png
│ │ ├── data-augmentation.png
│ │ ├── data-normalization.png
│ │ ├── dropout-nn.png
│ │ ├── dropout.png
│ │ ├── early-stopping.png
│ │ ├── gradient-descent-formula.png
│ │ ├── he-normal.png
│ │ ├── he-uniform.png
│ │ ├── how-to-gradient-descent.png
│ │ ├── hyperparameter.png
│ │ ├── leaky-relu.png
│ │ ├── lecun-normal.png
│ │ ├── lecun-uniform.png
│ │ ├── local-and-global-minimum.png
│ │ ├── local-minima-problem.png
│ │ ├── momentum-vs-nag.png
│ │ ├── momentum.png
│ │ ├── nag.png
│ │ ├── noise-robustness.png
│ │ ├── parameter-norm-penalty.png
│ │ ├── parameter-vs-hyperparameter.png
│ │ ├── relu-approximate.png
│ │ ├── relu.png
│ │ ├── rmsprop.png
│ │ ├── saddle-point.png
│ │ ├── selu-elu.png
│ │ ├── sigmoid-formula.png
│ │ ├── sigmoid.png
│ │ ├── static-dynamic-graph.png
│ │ ├── step-size-problem.png
│ │ ├── tanh.png
│ │ ├── xavier-normal.png
│ │ └── xavier-uniform.png
│ ├── 4-python
│ │ ├── array-type.png
│ │ ├── lambda-function.png
│ │ ├── library.png
│ │ ├── namespace.png
│ │ ├── numpy-array.png
│ │ └── package.png
│ ├── 5-network
│ │ ├── 3-way-handshake.png
│ │ ├── 4-way-handshake.png
│ │ ├── browser-access-trip.png
│ │ ├── bus-topology.png
│ │ ├── capsulation.png
│ │ ├── cors.png
│ │ ├── data-encapsulation.png
│ │ ├── dns.png
│ │ ├── http-request-response.png
│ │ ├── ipv4-ipv6.png
│ │ ├── mesh-full-topology.png
│ │ ├── mesh-part-topology.png
│ │ ├── network-class.png
│ │ ├── network-delay.png
│ │ ├── osi-7-layer.png
│ │ ├── request-response-header.png
│ │ ├── ring-topology.png
│ │ ├── router-switch-hub.png
│ │ ├── routing.png
│ │ ├── star-topology.png
│ │ ├── tcp-ip-hierarchy.png
│ │ ├── tcp-segment.png
│ │ ├── udp-segment.png
│ │ ├── uri.png
│ │ └── web-socket.png
│ ├── 6-operating-system
│ │ ├── context-switching.png
│ │ ├── demand-paging.png
│ │ ├── fragmentation.png
│ │ ├── hit-rate.png
│ │ ├── memory-fragmentation.png
│ │ ├── multi-thread-model.png
│ │ ├── paging.png
│ │ ├── process.png
│ │ ├── scheduling-level.png
│ │ ├── segmentation-method.png
│ │ ├── segmentation.png
│ │ ├── swapping.png
│ │ ├── sync-async.png
│ │ ├── thread.png
│ │ └── user-kernel-thread.png
│ ├── 7-data-structure
│ │ ├── adjacent-list.png
│ │ ├── adjacent-matrix.png
│ │ ├── b-tree.png
│ │ ├── basic-linked-list.png
│ │ ├── binary-tree.png
│ │ ├── bst.png
│ │ ├── circular-linked-list.png
│ │ ├── circular-queue.png
│ │ ├── complete-binary-tree.png
│ │ ├── double-linked-list.png
│ │ ├── full-binary-tree.png
│ │ ├── graph.png
│ │ ├── hash-table.png
│ │ ├── max-heap.png
│ │ ├── min-heap.png
│ │ ├── queue.png
│ │ ├── red-black-tree.png
│ │ ├── separate-chaining.png
│ │ ├── single-linked-list.png
│ │ ├── stack.png
│ │ └── tree-terms.png
│ └── 8-algorithm
│ │ ├── bfs-dfs.png
│ │ ├── bubble-sort.png
│ │ ├── complexity.png
│ │ ├── counting-sort.png
│ │ ├── floyd.png
│ │ ├── heap-sort.png
│ │ ├── insertion-sort.png
│ │ ├── kruskal.png
│ │ ├── merge-sort.png
│ │ ├── prim.png
│ │ ├── quick-sort.png
│ │ ├── radix-sort.png
│ │ └── selection-sort.png
└── statistics-math-distribution.md
└── logo.png
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | | **⚠ PR 템플릿은 수정하지 말아주세요!**
**🔥 [PR 작성 규칙](https://github.com/boostcamp-ai-tech-4/ai-tech-interview/discussions/182#discussion-4321560)을 준수하지 않는 PR은 거절됩니다. 꼭 읽어주세요.**|
2 | | :--- |
3 |
4 |
5 | ## 🔎 What is this PR?
6 |
7 | ### 분야
8 |
9 | > **`필수` 수정하려는 답변의 분야를 선택해주세요. 이외 수정사항은 기타를 선택하시고 오른쪽에 추가 설명 부탁드립니다.**
10 |
11 | - [ ] 통계/수학
12 | - [ ] 머신러닝
13 | - [ ] 딥러닝
14 | - [ ] 파이썬
15 | - [ ] 네트워크
16 | - [ ] 운영체제
17 | - [ ] 자료구조
18 | - [ ] 알고리즘
19 | - [ ] 기타:
20 |
21 | ### 수정 내용
22 |
23 | > **`필수` 어떻게 수정하셨는지 자세히 작성 부탁드립니다.**
24 |
25 | ### 참고 자료
26 |
27 | > **`선택` 수정 시 참고한 문서가 있다면 링크 작성 부탁드립니다.**
28 |
29 | ## ✅ PR Checklists
30 |
31 | > **`필수` 아래 체크리스트 확인 부탁드립니다. 모두 체크된 PR만 확인 가능합니다.**
32 |
33 | - [ ] [PR 작성 규칙](https://github.com/boostcamp-ai-tech-4/ai-tech-interview/discussions/182)을 준수하셨나요?
34 | - [ ] **"1문제 1PR" 원칙**을 준수하셨나요?
35 | - [ ] PR 템플릿에 맞춰서 PR을 작성하셨나요?
36 | - [ ] PR 제목은 "[분야] 수정내용"로 되어있나요? (분야는 **한글 명칭**만 가능 ex. 딥러닝, 머신러닝)
37 | - [ ] PR이 **①미적으로 나아졌을 경우 ②답변이 개선된 경우** 두 가지 중 하나에 해당되나요?
38 | - [ ] LaTeX 문법을 준수하셨나요? (참고: [GitHub 수식 기능 공지](https://github.blog/2022-05-19-math-support-in-markdown/))
39 | - [ ] upstream 레포의 최신 브랜치와 동일한 main 브랜치에서 분기하여 수정하셨나요?
40 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Created by https://www.toptal.com/developers/gitignore/api/windows,macos,linux
2 | # Edit at https://www.toptal.com/developers/gitignore?templates=windows,macos,linux
3 |
4 | ### Linux ###
5 | *~
6 |
7 | # temporary files which can be created if a process still has a handle open of a deleted file
8 | .fuse_hidden*
9 |
10 | # KDE directory preferences
11 | .directory
12 |
13 | # Linux trash folder which might appear on any partition or disk
14 | .Trash-*
15 |
16 | # .nfs files are created when an open file is removed but is still being accessed
17 | .nfs*
18 |
19 | ### macOS ###
20 | # General
21 | .DS_Store
22 | .AppleDouble
23 | .LSOverride
24 |
25 | # Icon must end with two \r
26 | Icon
27 |
28 |
29 | # Thumbnails
30 | ._*
31 |
32 | # Files that might appear in the root of a volume
33 | .DocumentRevisions-V100
34 | .fseventsd
35 | .Spotlight-V100
36 | .TemporaryItems
37 | .Trashes
38 | .VolumeIcon.icns
39 | .com.apple.timemachine.donotpresent
40 |
41 | # Directories potentially created on remote AFP share
42 | .AppleDB
43 | .AppleDesktop
44 | Network Trash Folder
45 | Temporary Items
46 | .apdisk
47 |
48 | ### macOS Patch ###
49 | # iCloud generated files
50 | *.icloud
51 |
52 | ### Windows ###
53 | # Windows thumbnail cache files
54 | Thumbs.db
55 | Thumbs.db:encryptable
56 | ehthumbs.db
57 | ehthumbs_vista.db
58 |
59 | # Dump file
60 | *.stackdump
61 |
62 | # Folder config file
63 | [Dd]esktop.ini
64 |
65 | # Recycle Bin used on file shares
66 | $RECYCLE.BIN/
67 |
68 | # Windows Installer files
69 | *.cab
70 | *.msi
71 | *.msix
72 | *.msm
73 | *.msp
74 |
75 | # Windows shortcuts
76 | *.lnk
77 |
78 | # End of https://www.toptal.com/developers/gitignore/api/windows,macos,linux
79 |
--------------------------------------------------------------------------------
/.mergify.yml:
--------------------------------------------------------------------------------
1 | pull_request_rules:
2 | - name: Assign yourself and request reviews automatically
3 | conditions:
4 | - -merged
5 | - -closed
6 | - base=main
7 | actions:
8 | assign:
9 | add_users:
10 | - CoodingPenguin
11 | request_reviews:
12 | users:
13 | - CoodingPenguin
14 | label:
15 | add:
16 | - "💬 feedback"
17 |
18 | - name: Automatic merge on approval
19 | conditions:
20 | - -closed
21 | - -merged
22 | - "#approved-reviews-by>=1"
23 | - "#changes-requested-reviews-by=0"
24 | - base=main
25 | actions:
26 | merge:
27 | method: merge
28 |
29 | - name: Add conflict label
30 | conditions:
31 | - -closed
32 | - -merged
33 | - conflict
34 | actions:
35 | comment:
36 | message: "@{{author}} Conflict 해결이 필요합니다!😥 cc. @CoodingPenguin"
37 | label:
38 | add:
39 | - "❗ conflict"
40 |
41 | - name: Remove conflict label
42 | conditions:
43 | - -closed
44 | - -merged
45 | - -conflict
46 | actions:
47 | label:
48 | remove:
49 | - "❗ conflict"
50 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2021 boost-devs
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 |
10 |
11 | ---
12 |
13 | ## Notice
14 |
15 | > [!WARNING]
16 | > PR 요청 시 [작성 규칙](https://github.com/boost-devs/ai-tech-interview/discussions/182)을 준수해주세요. **준수하지 않을 시 해당 PR은 거절될 수 있습니다.**
17 |
18 | - 피드백은 [Pull Request를 통한 피드백 요청 방법](https://github.com/boost-devs/ai-tech-interview/discussions/181)을 참고하여 Pull Request로 보내주세요.
19 | - Pull Request 작성 규칙은 [여기](https://github.com/boost-devs/ai-tech-interview/discussions/182)를 참고해주세요.
20 | - GitHub 외에 [GitBook 사이트](https://boostdevs.gitbook.io/ai-tech-interview/)로도 보실 수 있습니다.
21 | - ~~하지만 Latex 문법이 달라 다른 웹사이트로 마이그레이션 예정입니다.~~ 시간될 때 마이그레이션 예정입니다..🥲
22 | - 궁금한 점이 있거나 공유하고 싶은 팁이 있으시면 [Discussion](https://github.com/boost-devs/ai-tech-interview/discussions/)을 활용해주세요.
23 | - 커뮤니티 활성화는 언제든지 환영입니다!
24 | - 면접 레포 개선 프로젝트 진행 상황은 [여기](https://github.com/boost-devs/ai-tech-interview/projects/2)를 확인해주세요.
25 | - [공지](https://github.com/boost-devs/ai-tech-interview/discussions/184)에서 말씀드린 것처럼 진행이 더딜 수 있습니다.
26 |
27 | ---
28 |
29 | ## Interview Questions
30 |
31 |
32 | 📈 통계/수학
33 |
34 | - 고유값(eigen value)와 고유벡터(eigen vector)이 무엇이고 왜 중요한지 설명해주세요.
35 | - 샘플링(Sampling)과 리샘플링(Resampling)이 무엇이고 리샘플링의 장점을 말씀해주세요.
36 | - 확률 모형과 확률 변수는 무엇인가요?
37 | - 누적 분포 함수와 확률 밀도 함수는 무엇인가요? 수식과 함께 표현해주세요.
38 | - 조건부 확률은 무엇인가요?
39 | - 공분산과 상관계수는 무엇일까요? 수식과 함께 표현해주세요.
40 | - 신뢰 구간의 정의는 무엇인가요?
41 | - p-value를 모르는 사람에게 설명한다면 어떻게 설명하실 건가요?
42 | - R square의 의미는 무엇인가요?
43 | - 평균(mean)과 중앙값(median)중에 어떤 케이스에서 뭐를 써야할까요?
44 | - 중심극한정리는 왜 유용한걸까요?
45 | - 엔트로피(entropy)에 대해 설명해주세요. 가능하면 Information Gain도요.
46 | - 어떨 때 모수적 방법론을 쓸 수 있고, 어떨 때 비모수적 방법론을 쓸 수 있나요?
47 | - “likelihood”와 “probability”의 차이는 무엇일까요?
48 | - 통계에서 사용되는 bootstrap의 의미는 무엇인가요.
49 | - 모수가 매우 적은 (수십개 이하) 케이스의 경우 어떤 방식으로 예측 모델을 수립할 수 있을까요?
50 | - 베이지안과 프리퀀티스트 간의 입장차이를 설명해주실 수 있나요?
51 | - 검정력(statistical power)은 무엇일까요?
52 | - missing value가 있을 경우 채워야 할까요? 그 이유는 무엇인가요?
53 | - 아웃라이어의 판단하는 기준은 무엇인가요?
54 | - 필요한 표본의 크기를 어떻게 계산합니까?
55 | - Bias를 통제하는 방법은 무엇입니까?
56 | - 로그 함수는 어떤 경우 유용합니까? 사례를 들어 설명해주세요.
57 | - 베르누이 분포 / 이항 분포 / 카테고리 분포 / 다항 분포 / 가우시안 정규 분포 / t 분포 / 카이제곱 분포 / F 분포 / 베타 분포 / 감마 분포에 대해 설명해주세요. 그리고 분포 간의 연관성도 설명해주세요.
58 | - 출장을 위해 비행기를 타려고 합니다. 당신은 우산을 가져가야 하는지 알고 싶어 출장지에 사는 친구 3명에게 무작위로 전화를 하고 비가 오는 경우를 독립적으로 질문해주세요. 각 친구는 2/3로 진실을 말하고 1/3으로 거짓을 말합니다. 3명의 친구가 모두 “그렇습니다. 비가 내리고 있습니다”라고 말했습니다. 실제로 비가 내릴 확률은 얼마입니까?
59 |
60 |
61 |
62 |
63 | 🤖 머신러닝
64 |
65 | - 알고 있는 metric에 대해 설명해주세요. (ex. RMSE, MAE, recall, precision ...)
66 | - 정규화를 왜 해야할까요? 정규화의 방법은 무엇이 있나요?
67 | - Local Minima와 Global Minimum에 대해 설명해주세요.
68 | - 차원의 저주에 대해 설명해주세요.
69 | - dimension reduction기법으로 보통 어떤 것들이 있나요?
70 | - PCA는 차원 축소 기법이면서, 데이터 압축 기법이기도 하고, 노이즈 제거기법이기도 합니다. 왜 그런지 설명해주실 수 있나요?
71 | - LSA, LDA, SVD 등의 약자들이 어떤 뜻이고 서로 어떤 관계를 가지는지 설명할 수 있나요?
72 | - Markov Chain을 고등학생에게 설명하려면 어떤 방식이 제일 좋을까요?
73 | - 텍스트 더미에서 주제를 추출해야 합니다. 어떤 방식으로 접근해 나가시겠나요?
74 | - SVM은 왜 반대로 차원을 확장시키는 방식으로 동작할까요? SVM은 왜 좋을까요?
75 | - 다른 좋은 머신 러닝 대비, 오래된 기법인 나이브 베이즈(naive bayes)의 장점을 옹호해보세요.
76 | - 회귀 / 분류시 알맞은 metric은 무엇일까?
77 | - Association Rule의 Support, Confidence, Lift에 대해 설명해주세요.
78 | - 최적화 기법중 Newton’s Method와 Gradient Descent 방법에 대해 알고 있나요?
79 | - 머신러닝(machine)적 접근방법과 통계(statistics)적 접근방법의 둘간에 차이에 대한 견해가 있나요?
80 | - 인공신경망(deep learning이전의 전통적인)이 가지는 일반적인 문제점은 무엇일까요?
81 | - 지금 나오고 있는 deep learning 계열의 혁신의 근간은 무엇이라고 생각하시나요?
82 | - ROC 커브에 대해 설명해주실 수 있으신가요?
83 | - 여러분이 서버를 100대 가지고 있습니다. 이때 인공신경망보다 Random Forest를 써야하는 이유는 뭘까요?
84 | - K-means의 대표적 의미론적 단점은 무엇인가요? (계산량 많다는것 말고)
85 | - L1, L2 정규화에 대해 설명해주세요.
86 | - Cross Validation은 무엇이고 어떻게 해야하나요?
87 | - XGBoost을 아시나요? 왜 이 모델이 캐글에서 유명할까요?
88 | - 앙상블 방법엔 어떤 것들이 있나요?
89 | - feature vector란 무엇일까요?
90 | - 좋은 모델의 정의는 무엇일까요?
91 | - 50개의 작은 의사결정 나무는 큰 의사결정 나무보다 괜찮을까요? 왜 그렇게 생각하나요?
92 | - 스팸 필터에 로지스틱 리그레션을 많이 사용하는 이유는 무엇일까요?
93 | - OLS(ordinary least squre) regression의 공식은 무엇인가요?
94 |
95 |
96 |
97 |
98 | 🧠 딥러닝
99 |
100 | - 딥러닝은 무엇인가요? 딥러닝과 머신러닝의 차이는?
101 | - Cost Function과 Activation Function은 무엇인가요?
102 | - Tensorflow, PyTorch 특징과 차이가 뭘까요?
103 | - Data Normalization은 무엇이고 왜 필요한가요?
104 | - 알고있는 Activation Function에 대해 알려주세요. (Sigmoid, ReLU, LeakyReLU, Tanh 등)
105 | - 오버피팅일 경우 어떻게 대처해야 할까요?
106 | - 하이퍼 파라미터는 무엇인가요?
107 | - Weight Initialization 방법에 대해 말해주세요. 그리고 무엇을 많이 사용하나요?
108 | - 볼츠만 머신은 무엇인가요?
109 | - TF, PyTorch 등을 사용할 때 디버깅 노하우는?
110 | - 뉴럴넷의 가장 큰 단점은 무엇인가? 이를 위해 나온 One-Shot Learning은 무엇인가?
111 | - 요즘 Sigmoid 보다 ReLU를 많이 쓰는데 그 이유는?
112 | - Non-Linearity라는 말의 의미와 그 필요성은?
113 | - ReLU로 어떻게 곡선 함수를 근사하나?
114 | - ReLU의 문제점은?
115 | - Bias는 왜 있는걸까?
116 | - Gradient Descent에 대해서 쉽게 설명한다면?
117 | - 왜 꼭 Gradient를 써야 할까? 그 그래프에서 가로축과 세로축 각각은 무엇인가? 실제 상황에서는 그 그래프가 어떻게 그려질까?
118 | - GD 중에 때때로 Loss가 증가하는 이유는?
119 | - Back Propagation에 대해서 쉽게 설명 한다면?
120 | - Local Minima 문제에도 불구하고 딥러닝이 잘 되는 이유는?
121 | - GD가 Local Minima 문제를 피하는 방법은?
122 | - 찾은 해가 Global Minimum인지 아닌지 알 수 있는 방법은?
123 | - Training 세트와 Test 세트를 분리하는 이유는?
124 | - Validation 세트가 따로 있는 이유는?
125 | - Test 세트가 오염되었다는 말의 뜻은?
126 | - Regularization이란 무엇인가?
127 | - Batch Normalization의 효과는?
128 | - Dropout의 효과는?
129 | - BN 적용해서 학습 이후 실제 사용시에 주의할 점은? 코드로는?
130 | - GAN에서 Generator 쪽에도 BN을 적용해도 될까?
131 | - SGD, RMSprop, Adam에 대해서 아는대로 설명한다면?
132 | - SGD에서 Stochastic의 의미는?
133 | - 미니배치를 작게 할때의 장단점은?
134 | - 모멘텀의 수식을 적어 본다면?
135 | - 간단한 MNIST 분류기를 MLP+CPU 버전으로 numpy로 만든다면 몇줄일까?
136 | - 어느 정도 돌아가는 녀석을 작성하기까지 몇시간 정도 걸릴까?
137 | - Back Propagation은 몇줄인가?
138 | - CNN으로 바꾼다면 얼마나 추가될까?
139 | - 간단한 MNIST 분류기를 TF, PyTorch 등으로 작성하는데 몇시간이 필요한가?
140 | - CNN이 아닌 MLP로 해도 잘 될까?
141 | - 마지막 레이어 부분에 대해서 설명 한다면?
142 | - 학습은 BCE loss로 하되 상황을 MSE loss로 보고 싶다면?
143 | - 딥러닝할 때 GPU를 쓰면 좋은 이유는?
144 | - GPU를 두개 다 쓰고 싶다. 방법은?
145 | - 학습시 필요한 GPU 메모리는 어떻게 계산하는가?
146 |
147 |
148 |
149 |
150 | 🐍 파이썬
151 |
152 | - What is the difference between list and tuples in Python?
153 | - What are the key features of Python?
154 | - What type of language is python? Programming or scripting?
155 | - Python an interpreted language. Explain.
156 | - What is pep 8?
157 | - How is memory managed in Python?
158 | - What is namespace in Python?
159 | - What is PYTHONPATH?
160 | - What are python modules? Name some commonly used built-in modules in Python?
161 | - What are local variables and global variables in Python?
162 | - Is python case sensitive?
163 | - What is type conversion in Python?
164 | - How to install Python on Windows and set path variable?
165 | - Is indentation required in python?
166 | - What is the difference between Python Arrays and lists?
167 | - What are functions in Python?
168 | - What is `__init__`?
169 | - What is a lambda function?
170 | - What is self in Python?
171 | - How does break, continue and pass work?
172 | - What does `[::-1]` do?
173 | - How can you randomize the items of a list in place in Python?
174 | - What’s the difference between iterator and iterable?
175 | - How can you generate random numbers in Python?
176 | - What is the difference between range & xrange?
177 | - How do you write comments in python?
178 | - What is pickling and unpickling?
179 | - What are the generators in python?
180 | - How will you capitalize the first letter of string?
181 | - How will you convert a string to all lowercase?
182 | - How to comment multiple lines in python?
183 | - What are docstrings in Python?
184 | - What is the purpose of is, not and in operators?
185 | - What is the usage of help() and dir() function in Python?
186 | - Whenever Python exits, why isn’t all the memory de-allocated?
187 | - What is a dictionary in Python?
188 | - How can the ternary operators be used in python?
189 | - What does this mean: `*args`, `**kwargs`? And why would we use it?
190 | - What does len() do?
191 | - Explain split(), sub(), subn() methods of “re” module in Python.
192 | - What are negative indexes and why are they used?
193 | - What are Python packages?
194 | - How can files be deleted in Python?
195 | - What are the built-in types of python?
196 | - What advantages do NumPy arrays offer over (nested) Python lists?
197 | - How to add values to a python array?
198 | - How to remove values to a python array?
199 | - Does Python have OOps concepts?
200 | - What is the difference between deep and shallow copy?
201 | - How is Multithreading achieved in Python?
202 | - What is the process of compilation and linking in python?
203 | - What are Python libraries? Name a few of them.
204 | - What is split used for?
205 | - How to import modules in python?
206 | - Explain Inheritance in Python with an example.
207 | - How are classes created in Python?
208 | - What is monkey patching in Python?
209 | - Does python support multiple inheritance?
210 | - What is Polymorphism in Python?
211 | - Define encapsulation in Python?
212 | - How do you do data abstraction in Python?
213 | - Does python make use of access specifiers?
214 | - How to create an empty class in Python?
215 | - What does an object() do?
216 | - What is map function in Python?
217 | - Is python numpy better than lists?
218 | - What is GIL in Python language?
219 | - What makes the CPython different from Python?
220 | - What are Decorators in Python?
221 | - What is object interning?
222 | - What is @classmethod, @staticmethod, @property?
223 |
224 |
225 |
226 |
227 | 🌐 네트워크
228 |
229 | - TCP/IP의 각 계층을 설명해주세요.
230 | - OSI 7계층와 TCP/IP 계층의 차이를 설명해주세요.
231 | - Frame, Packet, Segment, Datagram을 비교해주세요.
232 | - TCP와 UDP의 차이를 설명해주세요.
233 | - TCP와 UDP의 헤더를 비교해주세요.
234 | - TCP의 3-way-handshake와 4-way-handshake를 비교 설명해주세요.
235 | - TCP의 연결 설정 과정(3단계)과 연결 종료 과정(4단계)이 단계가 차이나는 이유가 무엇인가요?
236 | - 만약 Server에서 FIN 플래그를 전송하기 전에 전송한 패킷이 Routing 지연이나 패킷 유실로 인한 재전송 등으로 인해 FIN 패킷보다 늦게 도착하는 상황이 발생하면 어떻게 될까요?
237 | - 초기 Sequence Number인 ISN을 0부터 시작하지 않고 난수를 생성해서 설정하는 이유가 무엇인가요?
238 | - HTTP와 HTTPS에 대해서 설명하고 차이점에 대해 설명해주세요.
239 | - HTTP 요청/응답 헤더의 구조를 설명해주세요.
240 | - HTTP와 HTTPS 동작 과정을 비교해주세요.
241 | - CORS가 무엇인가요?
242 | - HTTP GET과 POST 메서드를 비교/설명해주세요.
243 | - 쿠키(Cookie)와 세션(Session)을 설명해주세요.
244 | - DNS가 무엇인가요?
245 | - REST와 RESTful의 개념을 설명하고 차이를 말해주세요.
246 | - 소켓(Socket)이 무엇인가요? 자신 있는 언어로 간단히 소켓 생성 예시를 보여주세요.
247 | - Socket.io와 WebSocket의 차이를 설명해주세요.
248 | - IPv4와 IPv6 차이를 설명해주세요.
249 | - MAC Address가 무엇인가요?
250 | - 라우터와 스위치, 허브의 차이를 설명해주세요.
251 | - SMTP가 무엇인가요?
252 | - 노트북으로 `www.google.com`에 접속을 했습니다. 요청을 보내고 받기까지의 과정을 자세히 설명해주세요.
253 | - 여러 네트워크 topology에 대해 간단히 소개해주세요.
254 | - subnet mask에 대해서 설명해주세요.
255 | - data encapsulation이 무엇인가요?
256 | - DHCP를 설명해주세요.
257 | - routing protocol을 몇 가지 설명해주세요. (ex. link state, distance vector)
258 | - 이더넷(ethernet)이 무엇인가요?
259 | - client와 server의 차이점을 설명해주세요.
260 | - delay, timing(jitter), throughput 차이를 설명해주세요.
261 |
262 |
263 |
264 |
265 | 🖥️ 운영체제
266 |
267 | - 프로세스와 스레드의 차이(Process vs Thread)를 알려주세요.
268 | - 멀티 프로세스 대신 멀티 스레드를 사용하는 이유를 설명해주세요.
269 | - 캐시의 지역성에 대해 설명해주세요.
270 | - Thread-safe에 대해 설명해주세요. (hint: critical section)
271 | - 뮤텍스와 세마포어의 차이를 설명해주세요.
272 | - 스케줄러가 무엇이고, 단기/중기/장기로 나누는 기준에 대해 설명해주세요.
273 | - CPU 스케줄러인 FCFS, SJF, SRTF, Priority Scheduling, RR에 대해 간략히 설명해주세요.
274 | - 동기와 비동기의 차이를 설명해주세요.
275 | - 메모리 관리 전략에는 무엇이 있는지 간략히 설명해주세요.
276 | - 가상 메모리에 대해 설명해주세요.
277 | - 교착상태(데드락, Deadlock)의 개념과 조건을 설명해주세요.
278 | - 사용자 수준 스레드와 커널 수준 스레드의 차이를 설명해주세요.
279 | - 외부 단편화와 내부 단편화에 대해 설명해주세요.
280 | - Context Switching이 무엇인지 설명하고 과정을 나열해주세요.
281 | - Swapping에 대해 설명해주세요.
282 |
283 |
284 |
285 |
286 | 🗂 자료구조
287 |
288 | - linked list
289 | - single linked list
290 | - double linked list
291 | - circular linked list
292 | - hash table
293 | - stack
294 | - queue
295 | - circular queue
296 | - graph
297 | - tree
298 | - binary tree
299 | - full binary tree
300 | - complete binary tree
301 | - bst(binary search tree)
302 | - heap(binary heap)
303 | - min heap
304 | - max heap
305 | - red-black tree
306 | - b+ tree
307 |
308 |
309 |
310 |
311 | 🔻 알고리즘
312 |
313 | - 시간, 공간 복잡도
314 | - Sort Algorithm
315 | - Bubble Sort
316 | - Selection Sort
317 | - Insertion Sort
318 | - Merge Sort
319 | - Heap Sort
320 | - Quick Sort
321 | - Counting Sort
322 | - Radix Sort
323 | - Divide and Conquer
324 | - Dynamic Programming
325 | - Greedy Algorithm
326 | - Graph
327 | - Graph Traversal: BFS, DFS
328 | - Shortest Path
329 | - Dijkstra
330 | - Floyd-Warshall
331 | - Bellman-Ford
332 | - Minimum Spanning Tree
333 | - Prim
334 | - Kruskal
335 | - Union-find
336 | - Topological sort
337 |
338 |
339 |
340 | ---
341 |
342 | ## Contributors
343 |
344 |
345 | 
346 |
347 |
348 | ---
349 |
350 | ## References
351 |
352 | - [zzsza님의 Datascience-Interview-Questions](https://github.com/zzsza/Datascience-Interview-Questions)
353 | - [DopplerHQ님의 awesome-interview-questions](https://github.com/DopplerHQ/awesome-interview-questions)
354 | - [JaeYeopHan님의 Interview_Question_for_Beginner](https://github.com/JaeYeopHan/Interview_Question_for_Beginner)
355 | - [WeareSoft님의 tech-interview](https://github.com/WeareSoft/tech-interview)
356 |
--------------------------------------------------------------------------------
/SUMMARY.md:
--------------------------------------------------------------------------------
1 | # Table of contents
2 |
3 | - [Notice](README.md)
4 |
5 | ## 🧑💻 INTERVIEW
6 |
7 | - [Statistics/Math](answers/1-statistics-math.md)
8 | - [Machine Learning](answers/2-machine-learning.md)
9 | - [Deep Learning](answers/3-deep-learning.md)
10 | - [Python](answers/4-python.md)
11 | - [Network](answers/5-network.md)
12 | - [Operating System](answers/6-operating-system.md)
13 | - [Data Structure](answers/7-data-structure.md)
14 | - [Algorithm](answers/8-algorithm.md)
15 |
16 |
--------------------------------------------------------------------------------
/answers/1-statistics-math.md:
--------------------------------------------------------------------------------
1 | > **📌 질문은 [zzsza님의 Datascience-Interview-Questions](https://github.com/zzsza/Datascience-Interview-Questions)를 참고하였습니다.**
2 |
3 | ## Table of Contents
4 |
5 | - [고유값(eigen value)와 고유벡터(eigen vector)이 무엇이고 왜 중요한지 설명해주세요.](#1)
6 | - [샘플링(Sampling)과 리샘플링(Resampling)이 무엇이고 리샘플링의 장점을 말씀해주세요.](#2)
7 | - [확률 모형과 확률 변수는 무엇인가요?](#3)
8 | - [누적 분포 함수와 확률 밀도 함수는 무엇인가요? 수식과 함께 표현해주세요.](#4)
9 | - [조건부 확률은 무엇인가요?](#5)
10 | - [공분산과 상관계수는 무엇일까요? 수식과 함께 표현해주세요.](#6)
11 | - [신뢰 구간의 정의는 무엇인가요?](#7)
12 | - [p-value를 모르는 사람에게 설명한다면 어떻게 설명하실 건가요?](#8)
13 | - [R square의 의미는 무엇인가요?](#9)
14 | - [평균(mean)과 중앙값(median)중에 어떤 케이스에서 뭐를 써야할까요?](#10)
15 | - [중심극한정리는 왜 유용한걸까요?](#11)
16 | - [엔트로피(entropy)에 대해 설명해주세요. 가능하면 Information Gain도요.](#12)
17 | - [어떨 때 모수적 방법론을 쓸 수 있고, 어떨 때 비모수적 방법론을 쓸 수 있나요?](#13)
18 | - [“likelihood”와 “probability”의 차이는 무엇일까요?](#14)
19 | - [통계에서 사용되는 bootstrap의 의미는 무엇인가요.](#15)
20 | - [모수가 매우 적은 (수십개 이하) 케이스의 경우 어떤 방식으로 예측 모델을 수립할 수 있을까요?](#16)
21 | - [베이지안과 프리퀀티스트 간의 입장차이를 설명해주실 수 있나요?](#17)
22 | - [검정력(statistical power)은 무엇일까요?](#18)
23 | - [missing value가 있을 경우 채워야 할까요? 그 이유는 무엇인가요?](#19)
24 | - [아웃라이어의 판단하는 기준은 무엇인가요?](#20)
25 | - [필요한 표본의 크기를 어떻게 계산합니까?](#21)
26 | - [Bias를 통제하는 방법은 무엇입니까?](#22)
27 | - [로그 함수는 어떤 경우 유용합니까? 사례를 들어 설명해주세요.](#23)
28 | - [베르누이 분포 / 이항 분포 / 카테고리 분포 / 다항 분포 / 가우시안 정규 분포 / t 분포 / 카이제곱 분포 / F 분포 / 베타 분포 / 감마 분포에 대해 설명해주세요.](#24)
29 | - [출장을 위해 비행기를 타려고 합니다. 당신은 우산을 가져가야 하는지 알고 싶어 출장지에 사는 친구 3명에게 무작위로 전화를 하고 비가 오는 경우를 독립적으로 질문했습니다. 각 친구는 2/3로 진실을 말하고 1/3으로 거짓을 말합니다. 3명의 친구가 모두 “그렇습니다. 비가 내리고 있습니다”라고 말했습니다. 실제로 비가 내릴 확률은 얼마입니까?](#25)
30 |
31 | ---
32 |
33 | ## #1
34 |
35 | ### 고유값(eigen value)와 고유벡터(eigen vector)이 무엇이고 왜 중요한지 설명해주세요.
36 |
37 | 정방행렬 $(n \times n)$인 $A$는 임의의 벡터 $(n \times 1)$인 $x$의 방향과 크기를 변화시킬 수 있다.
38 |
39 | 수많은 벡터 $x$중 어떤 벡터들은 $A$에 의해 선형 변환되었을 때에도 원래 벡터와 평행한 경우가 있다. **이렇듯 $Ax$가 원래 $x$에 상수 $\lambda$를 곱한 것과 같을 때의 $x$를 고유 벡터, 람다를 고유값이라 한다.**
40 |
41 | $$
42 | Ax = \lambda x
43 | $$
44 |
45 | 아래처럼 $x_1$은 $A$에 의해 변환되었음에도 $x_1$과 평행하다. 따라서 $x_1$은 고유벡터이다.
46 |
47 | 
48 |
49 | 고유값과 고유벡터를 통해 $A$를 고유값과 고유벡터들로 분해하는 **고유값 분해(eigen decomposition)**, 정방행렬 뿐만 아닌 $m \times n$행렬도 분해할 수 있는 **특이값 분해(SVD)**, 데이터들을 차원 축소시킬 때 가장 원래 의미를 잘 보존시키는 **주성분 분석(PCA)** 등에 활용할 수 있으므로 중요하다.
50 |
51 | #### References
52 |
53 | - [고유값과 고유 벡터 - 러너게인](https://twlab.tistory.com/46)
54 | - [머신러닝 - 19. 고유값(eigenvalue), 고유벡터(eigenvector), 고유값 분해(eigen decomposition) - 귀퉁이 서재](https://bkshin.tistory.com/entry/%EB%A8%B8%EC%8B%A0%EB%9F%AC%EB%8B%9D-19-%ED%96%89%EB%A0%AC)
55 | - [[선형대수학 #4] 특이값 분해(Singular Value Decomposition, SVD)의 활용 - 다크 프로그래머](https://darkpgmr.tistory.com/106)
56 | - [주성분 분석(PCA) - 공돌이의 수학정리노트](https://angeloyeo.github.io/2019/07/27/PCA.html)
57 |
58 | ---
59 |
60 | ## #2
61 |
62 | ### 샘플링(Sampling)과 리샘플링(Resampling)이 무엇이고 리샘플링의 장점을 말씀해주세요.
63 |
64 | 샘플링이란 **표본추출**을 의미하는 것으로, 모집단 전체에 대한 추정치(estimate)를 얻기 위해 임의의 sample을 뽑아내는 것이다.
65 | 모집단 전체에 대한 조사는 불가능하기 때문에 sample을 이용하여 모집단에 대한 추론(inference)을 하게되는 것이다.
66 | 하지만 표본은 모집단을 닮은 모집단의 mirror image 같은 존재이지만, 모집단 그 자체일수는 없다.
67 | 따라서 표본에는 반드시 모집단의 원래 패턴에서 놓친 부분, 즉 **noise가 존재할 수 밖에 없다.**
68 |
69 | 리샘플링은 **모집단의 분포 형태를 알 수 없을 때 주로 사용하는 방법**이다.
70 | 즉, 모분포를 알 수 없으므로 일반적인 통계적 공식들을 사용하기 힘들 때, 현재 갖고 있는 데이터를 이용하여 모분포와 비슷할 것으로 추정되는 분포를 만들어 보자는 것이다.
71 | 리샘플링은 **가지고 있는 샘플에서 다시 샘플 부분집합을 뽑아서 통계량의 변동성(variability of statistics)을 확인하는 것**이라고 할 수 있다.
72 | 즉, 같은 샘플을 여러 번 사용해서 성능을 측정하는 방식이다. 가장 많이 사용되는 방법이며 종류로는 K-fold 교차 검증, 부트스트래핑이 있다.
73 |
74 | 리샘플링은 표본을 추출하면서 원래 데이터 셋을 복원하기 때문에 이를 통해서 모집단의 분포에 어떤 가정도 필요 없이 표본만으로 추론이 가능하다는 장점이 있다.
75 |
76 | #### References
77 |
78 | - [(데이터과학 인터뷰 질문)(2) 샘플링과 리샘플링, 1편 - CHAOS & PATTERN : 데이터 사이언스 블로그](https://cnp-0717.tistory.com/7?category=838077)
79 | - [샘플링과 리샘플링의 차이는 무엇일까? - 김감귤](https://kejdev.github.io/posts/sampling-resampling/)
80 | - [resampling을 이용한 방법 (bootstrapping) - 진화하자 - 어디에도 소속되지 않기](https://adnoctum.tistory.com/296)
81 | - [샘플링과 리샘플링 - Wriggling](https://trampled-worm.tistory.com/91)
82 |
83 | ---
84 |
85 | ## #3
86 |
87 | ### 확률 모형과 확률 변수는 무엇인가요?
88 |
89 | **확률변수(Random Variable)** 란, 표본 공간의 각 단위 사건에 실수 값을 부여하는 변수이다. 확률변수는 어떠한 함수로 해석할 수 있으므로 `대문자 X`라고 표기한다.
90 | 무작위(Random) 실험을 했을 때, 특정 확률로 발생하는 각각의 결과를 수치적 값으로 표현하는 변수라고 할 수 있다.
91 | 또한 확률 변수에는 `이산확률변수`, `연속확률변수` 두가지 경우가 있다. `이산확률변수`는 확률변수 $X$가 취할 수 있는 값이 유한하기 떄문에 셀 수 있는 확률변수이다. 반면에 `연속확률변수`는 어떠한 두 수 사이에 반드시 다른 수가 존재하는, 셀 수 없는 범위의 확률변수를 가지는 경우에 사용된다.
92 |
93 | 주사위 굴리기 예제를 생각해보자.
94 |
95 | ```text
96 | 일단 주사위를 굴리는 상황은 어떤 수가 나올지 모르므로, 확률상황이다.
97 | "주사위를 굴렸을 때 나오는 값"을 확률변수 X라고 할 수 있다.
98 | 1~6이 표본공간이 되고, 셀 수 있으므로 이산확률변수가 된다.
99 | P(X=1)와 같은 식으로 표현하고, 이는 "주사위를 굴렸을 때, 1이라는 값이 나올 확률"로 해석할 수 있다.
100 | ```
101 |
102 | **확률모형(Probability Model)** 이란 확률변수를 이용하여 데이터의 분포를 수학적으로 정의한 모형이다.
103 | 데이터 분포를 묘사하기 위해서 사용된다.
104 | 보통 **확률 분포 함수(probability distribution function)** 또는 확률 밀도 함수(probability density function)를 주로 사용하며, 이때 함수의 계수를 분포의 모수(parameter)라고 부른다.
105 | **확률분포(Probability Distribution)** 란 표본공간에 정의된 확률을 이용하여 확률변수의 값 또는 영역에 대한 확률을 표현한 것이다.
106 | 예를 들어 가장 널리 쓰이는 확률 모형의 하나인 `가우시안 정규 분포(Gaussian normal distribution)`는 다음과 같은 수식으로 확률 밀도 함수를 정의한다.
107 |
108 | $$
109 | N(x ; \mu, \sigma) = \frac{1}{\sigma \sqrt{2 \pi}} e^{-\frac{(x- \mu)^2}{2 \sigma^2}}
110 | $$
111 |
112 | 다음과 같은 함수들이 확률모형에 포함될 수 있다. (자세한 내용은 [확률통계 기초용어 - EG 공간](https://kongdols-room.tistory.com/131) 참고)
113 |
114 | - 확률질량함수(PMF, Probability Mass Function) - 이산형
115 | - 확률밀도함수(PDF, Probability Density Function) - 연속형
116 | - 누적분포함수(CDF, Cumulative Distribution Function)
117 |
118 | 추가적으로 **확률 통계의 기초 용어**를 정리하면 다음과 같다. (주사위 굴리기 예제 사용)
119 |
120 | ```text
121 | - 실험(Experiment)은 하나의 행위가 하나 이상의 결과를 도출하는 것에 대한 과정 혹은 절차를 나타낸다.
122 | - 예시) 주사위를 던진다.
123 | - 결과(Outcome)는 어떤 실험에 의해 발생 가능한 결과이다. 특정 실험의 가능한 결과들은 각각 유일(unique)하다. 한번의 실험을 시행했을 때, 단 하나의 outcome만을 나타낸다.
124 | - 예시) 주사위의 눈 (ex. 3, 4, 6)
125 | - 표본 공간(Sample space)은 확률 실험에서 발생할 수 있는 모든 결과로 구성된 집합(set)이다. 발생할 수 있는 모든 결과의 집합이므로, 중복된 원소를 가질 수 있다.
126 | - 예시) 가능한 주사위의 모든 눈 집합 (ex. Ω = {1, 2, 3, 4, 5, 6})
127 | - 사건(Event)은 우리가 관심있는 Sample space의 부분집합이다.
128 | - 예시) 주사위 눈이 3이 나온다, 짝수/홀수가 나온다.
129 | ```
130 |
131 | #### References
132 |
133 | - [확률변수와 확률모형 - 숨니의 무작정 따라하기](https://sumniya.tistory.com/24)
134 | - [확률변수와 확률함수 - 필로홍의 데이터 노트](https://drhongdatanote.tistory.com/49)
135 | - [확률변수의 개념, 의미 - 로스카츠의 AI 머신러닝](https://losskatsu.github.io/statistics/random-variable/#%EC%9D%B4%EC%82%B0%ED%99%95%EB%A5%A0%EB%B6%84%ED%8F%AC)
136 | - [확률모형이란 - notebook.community](https://notebook.community/zzsza/Datascience_School/09.%20%EA%B8%B0%EC%B4%88%20%ED%99%95%EB%A5%A0%EB%A1%A02%20-%20%ED%99%95%EB%A5%A0%20%EB%B3%80%EC%88%98/03.%20%ED%99%95%EB%A5%A0%20%EB%AA%A8%ED%98%95%EC%9D%B4%EB%9E%80)
137 | - [확률통계 기초용어 - EG 공간](https://kongdols-room.tistory.com/131)
138 | - [[통계학] 9. 확률변수와 확률분포- 러닝머신의 Train Data Set](https://m.blog.naver.com/nilsine11202/221378790554)
139 |
140 | ---
141 |
142 | ## #4
143 |
144 | ### 누적 분포 함수와 확률 밀도 함수는 무엇인가요? 수식과 함께 표현해주세요.
145 |
146 | 확률 변수 $X$가 임의의 실수 집합 $B$에 포함되는 사건의 확률이 다음과 같이 어떤 음이 아닌 함수 $f$의 적분으로 주어진다고 하자.
147 |
148 | $$
149 | P(X \in B) = \int_{B} f(x) dx
150 | $$
151 |
152 | 이 때의 $X$를 연속확률변수라고 하며, 함수 $f(x)$를 확률 밀도 함수(Probability Density Function, PDF)라고 한다. 단, 실수 집합 $B$가 실수 전체일 경우 실수 전체에 대한 확률밀도함수의 적분은 1을 만족해야 한다.
153 |
154 | $$
155 | P(X \in R) = \int_{R} f(x) dx = 1
156 | $$
157 |
158 | 누적 분포 함수(Cumulative Distribution Function, CDF)는 확률변수가 특정 값보다 작거나 같을 확률을 나타내는 함수이다. 특정 값을 $a$라고 할 때, 누적 분포 함수는 다음과 같이 나타낼 수 있다.
159 |
160 | $$
161 | F(a) = P(X ≤ a) = \int^a_{-\infty} f(x) dx
162 | $$
163 |
164 | 확률 밀도 함수와 누적 분포 함수는 **미분과 적분의 관계**를 갖는다. 확률 밀도 함수를 음의 무한대에서 특정값 $a$까지 적분을 하면, $a$에 대한 누적 분포 함수를 얻을 수 있다. 반대로 누적 분포 함수를 미분하면 확률 밀도 함수를 얻을 수 있다.
165 |
166 | #### References
167 |
168 | - [확률및통계 강의노트 - 홍영훈 교수님](https://sites.google.com/site/hong0108/)
169 | - [확률 분포 함수와 확률 밀도 함수의 의미 - groovallstar.log](https://velog.io/@groovallstar/%ED%99%95%EB%A5%A0-%EB%B6%84%ED%8F%AC-%ED%95%A8%EC%88%98%EC%99%80-%ED%99%95%EB%A5%A0-%EB%B0%80%EB%8F%84-%ED%95%A8%EC%88%98%EC%9D%98-%EC%9D%98%EB%AF%B8)
170 |
171 | ---
172 |
173 | ## #5
174 |
175 | ### 조건부 확률은 무엇인가요?
176 |
177 | 조건부 확률은 사건 $A$가 일어났다는 전제 하에 사건 $B$가 일어날 확률이다. 이는 $P(B|A) = P(B \cap A) / P(A)$로 표현 가능하다. 조건부 확률은 **베이즈 정리**와도 이어지며, 조건부 확률을 이용한 가장 유명한 문제는 [몬티홀 문제](https://terms.naver.com/entry.naver?docId=3569086&cid=58944&categoryId=58970)가 있다.
178 |
179 | > **베이즈 정리**
180 |
181 | 베이즈 정리를 통해 가능도(Likelihood)와 증거(Evidence)를 바탕으로 사전확률을 사후확률로 업데이트한다.
182 |
183 | 
184 |
185 | - $D$: 새로 관찰되는 데이터
186 | - $\theta$: 모델에서 계산하고 싶어하는 모수 (가설)
187 | - 사후확률(Posterior): 데이터를 관찰했을 때, 이 가설이 성립할 확률 (데이터 관찰 이후 측정하기 때문에 사후확률)
188 | - 사전확률(Prior): 가설에 대해 사전에 세운 확률 (데이터 관측 이후 사후확률이 사전확률이 된다.)
189 | - 가능도(Likelihood): 현재 주어진 모수 (가정) 에서 이 데이터가 관찰될 가능성
190 | - 증거(Evidence): 데이터 전체의 분포
191 |
192 | #### References
193 |
194 | - [조건부 확률 - Truth in Engineering](https://m.blog.naver.com/PostView.nhn?blogId=mykepzzang&logNo=220834864348&proxyReferer=https:%2F%2Fwww.google.com%2F)
195 | - [통계학 맛보기 - Heath](https://velog.io/@dldydldy75/%EB%B2%A0%EC%9D%B4%EC%A6%88-%ED%86%B5%EA%B3%84%ED%95%99-%EB%A7%9B%EB%B3%B4%EA%B8%B0)
196 |
197 | ---
198 |
199 | ## #6
200 |
201 | ### 공분산과 상관계수는 무엇일까요? 수식과 함께 표현해주세요.
202 |
203 | 공분산은 확률변수 X의 편차(평균으로부터 얼마나 떨어져 있는지)와 확률변수 Y의 편차를 곱한 것의 평균값이다.
204 |
205 | $$
206 | Cov(X, Y) = E((X - \mu_X)(Y-\mu_Y))
207 | $$
208 |
209 | 공분산은 두 변수 간에 양의 상관관계가 있는지, 음의 상관관계가 있는지 정도를 알려준다. 하지만 상관관계가 얼마나 큰지는 제대로 반영하지 못한다.
210 |
211 | 공분산의 문제는 확률변수의 단위 크기에 영향을 많이 받는다는 것이다. 이를 보완할 수 있는 것이 바로 상관계수이다.
212 |
213 | 상관계수는 확률변수의 절대적 크기에 영향을 받지 않도록 공분산을 단위화시킨 것이다. 즉, 공분산에 각 확률변수의 분산을 나눠주었다.
214 |
215 | $$
216 | \rho = \frac{Cov(X, Y)}{\sqrt{Var(X) \cdot Var(Y)}}, \quad -1 ≤ \rho≤ 1
217 | $$
218 |
219 | 상관계수는 양의 상관관계가 있는지 음의 상관관계가 있는지 알려줄 뿐만 아니라, 그 상관성이 얼마나 큰지도 알려준다. 1 또는 -1에 가까울수록 상관성이 큰 것이고, 0에 가까울수록 상관성이 작은 것이다.
220 |
221 | #### References
222 |
223 | - [공분산과 상관계수의 이해.txt - bskyvision](https://bskyvision.com/398)
224 | - [공분산(Covariance)과 상관계수(Correlation) - Serious Archive](https://destrudo.tistory.com/15)
225 |
226 | ---
227 |
228 | ## #7
229 |
230 | ### 신뢰 구간의 정의는 무엇인가요?
231 |
232 | 구간 추정에서 모수가 a 에서 b 사이에 있을 것으로 추정(신뢰구간)하고 그 확률(%, 신뢰수준)을 구한다.
233 |
234 | 
235 |
236 | **신뢰구간(Confidence Interval)** 은 모집단의 모수(parameter)가 위치해 있을 것으로 신뢰할 수 있는 구간이다.
237 | 모수가 어느 범위 안에 있는지를 확률적으로 보여주는 방법이라고 할 수 있다.
238 | 신뢰구간을 구하는 이유는 모수의 신뢰성을 가늠하기 위함이다.
239 |
240 | 추가적으로, 신뢰구간에 대한 정확한 해석은 모평균을 포함할 확률이 95%가 되는 구간이 아닌, 같은 방법으로 100번 표본을 추출했을 때, 함께 계산되는 100개의 신뢰구간 중 모평균을 포함한 신뢰구간들의 숫자가 95개정도 된다라고 해야한다. 왜냐면, 모평균은 이미 정해져 있는 값이므로 전자의 해석을 사용할 수 없기 때문이다.
241 |
242 | **신뢰수준**은 방법의 정확도, 참값을 구하기 위한 작업을 많이 반복했을 때, 참값이 특정 범위에 있는 비율이다.
243 |
244 | **모수(Parameter)** 는 모집단의 특성을 보여주는 값이다. 예를들어, 평균, 분산 등의 고정인 값이 있을 수 있다.
245 |
246 | #### References
247 |
248 | - [COMPUTATAIONAL PREDICTION - Minkoo Seo blog](http://mkseo.pe.kr/stats/?p=763)
249 | - [신뢰구간 - 위키백과](https://ko.wikipedia.org/wiki/%EC%8B%A0%EB%A2%B0_%EA%B5%AC%EA%B0%84)
250 | - [신뢰구간의 의미 - 공돌이의 수학정리노트](https://angeloyeo.github.io/2021/01/05/confidence_interval.html)
251 |
252 | ---
253 |
254 | ## #8
255 |
256 | ### p-value를 모르는 사람에게 설명한다면 어떻게 설명하실 건가요?
257 |
258 | p-value를 알기 위해서는 먼저 1종 오류를 알아야 한다. 여기서 1종 오류란 **귀무가설이 참인데 기각한 경우**을 말한다. 귀무가설이란 기존의 주장을 말하며, 이와 반대로 새로운 주장을 대립가설이라고 한다.
259 |
260 | 예를 들어, 어느 제약회사에서 치료약 A를 개발했다. 기존에는 치료약 A가 없었으므로 귀무가설은 "치료약 A가 효과가 없다"라고 설정한다. 반대로 대립가설은 "치료약 A는 효과가 있다"로 설정한다. 회사에서는 검정을 한 결과, 귀무가설을 기각하고 대립가설을 채택했다. 치료약 A는 판매되었고 높은 매출을 기록했다. 그런데 알고보니 치료약 A가 효과가 없다는 것이 밝혀졌다. 참인 귀무가설을 기각했기에 이는 1종 오류가 일어났다고 볼 수 있다.
261 |
262 | 다시 돌아와서 p-value는 **1종 오류를 범할 확률**을 말한다. 예를 들어, p-value가 5%라면, 100번 중 5번 1종 오류가 발생한다는 말이다. 검정을 할 때는 유의 수준 $\alpha$를 정하는데, 이것이 1종 오류의 상한선이 된다. 그래서 유의 수준보다 p-value가 작다면 실험의 오류가 상한선보다 작으므로 귀무가설을 기각하고 대립가설을 채택한다. 만약 크다면 상한선을 넘었으므로 귀무가설을 채택한다.
263 |
264 | #### References
265 |
266 | - [p-value의 의미 - 공돌이의 수학정리노트](https://angeloyeo.github.io/2020/03/29/p_value.html)
267 | - [p-value란 무엇인가 - 진화하자 어디에도 소속되지 않기](https://adnoctum.tistory.com/332)
268 | - [통계, 기본 개념을 정리해보자 - 이지훈](https://brunch.co.kr/@jihoonleeh9l6/34)
269 | - [유의수준(Significance Level)과 p값(p-value) - 통계학과 사색의 공간](https://m.blog.naver.com/vnf3751/220830413960)
270 |
271 | ---
272 |
273 | ## #9
274 |
275 | ### R square의 의미는 무엇인가요?
276 |
277 | 결정계수(R square)는 선형 회귀 모델에서 데이터에 대해 회귀선이 얼마나 잘 설명하는지에 대한 설명력을 의미한다. 결정계수는 0~1 의 값을 가질 수 있고, 만약 값이 1 이라면 회귀선으로 모든 데이터를 다 설명할 수 있다고 이해할 수 있다.
278 |
279 | 참고로 결정계수는 다음의 식으로 구할 수 있다.
280 |
281 | $$
282 | R^2 = SSE/SST = 1 - SSR/SST
283 | $$
284 |
285 | - $SSE = \sum(\text{추정값 - 관측값 평균})^2$
286 | - $SST = \sum(\text{관측값 - 관측값 평균})^2$
287 | - $SSR = \sum(\text{관측값 - 추정값})^2$
288 |
289 | 관측값은 실제 데이터의 값을 말하며, 추정값은 회귀 모델을 통해 나온 값을 말한다. 회귀 모델의 성능을 평가하는 방법은 결정계수 외에도 MAE, MSE, RMSE 가 있다.
290 |
291 | #### References
292 |
293 | - [결정계수의 의미와 계산 방법](https://m.blog.naver.com/tlrror9496/222055889079)
294 | - [회귀분석에서 R스퀘어의 정확한 의미](https://m.blog.naver.com/PostView.nhn?blogId=will84&logNo=220348748198&proxyReferer=https:%2F%2Fwww.google.com%2F)
295 | - [모델 성능 평가](https://heung-bae-lee.github.io/2020/01/09/machine_learning_03/)
296 |
297 | ---
298 |
299 | ## #10
300 |
301 | ### 평균(mean)과 중앙값(median)중에 어떤 케이스에서 뭐를 써야할까요?
302 |
303 | - `평균(mean)`: 모든 관측값의 합을 자료의 개수로 나눈 것
304 | - `중앙값(median)`: 전체 관측값을 크기 순서로 배열했을 때 가운데 위치하는 값
305 |
306 | 평균은 전체 관측값이 골고루 반영되므로 대표값으로서 가치가 있다. 평균 근처에 **표본이 몰려 있는 상황에서 대표값으로 유용**하지만 극단적인 값에 영향을 많이 받는다.
307 |
308 | 중앙값에서는 관측값을 크기 순서로 배열할 때 관측값의 위치가 중요하고, 가운데 위치한 관측값 이외의 관측값들의 크기는 중요하지 않다. 따라서 평균과는 달리 중앙값은 관측값들의 변화에 민감하지 않고 특히 아주 큰 관측값이나 아주 작은 관측값(즉, outlier)에 영향을 받지 않는다. 중앙값이 유용한 경우는 **표본의 편차, 혹은 왜곡이 심하게 나타나는 경우**이다.
309 |
310 | #### References
311 |
312 | - [평균(average, mean) vs. 중간값(median) | 통계상의 오류가능성 - 슈퍼짱짱](https://leedakyeong.tistory.com/entry/%ED%8F%89%EA%B7%A0-%EC%A4%91%EC%95%99%EA%B0%92-%EC%B5%9C%EB%B9%88%EA%B0%92-%EB%B9%84%EA%B5%90-Mean-VS-Median-VS-Mode)
313 | - [[기초통계] 평균 중앙값 최빈값 비교 (Mean VS Median VS Mode) - Peter Hwang](https://blog.naver.com/ricemankr/220796823014)
314 |
315 | ---
316 |
317 | ## #11
318 |
319 | ### 중심극한정리는 왜 유용한걸까요?
320 |
321 | **중심극한정리**란 크기가 n인 표본추출(30개 이상)이 무수히 많이 수행되면(최소 100회 이상을 의미), 표본 평균의 분포가 정규분포에 수렴한다는 것이다. 중심극한정리가 유용한 이유는 **모집단의 형태가 어떻든지 간에 상관없이 표본 평균의 분포가 정규분포를 따르기 때문**이다.
322 |
323 | #### References
324 |
325 | - [중심극한정리의 의미 - 공돌이의 수학정리노트](https://angeloyeo.github.io/2020/09/15/CLT_meaning.html)
326 |
327 | ---
328 |
329 | ## #12
330 |
331 | ### 엔트로피(Entropy)에 대해 설명해주세요. 가능하면 정보이득(Information Gain)도요.
332 |
333 | **엔트로피**는 주어진 데이터의 혼잡도를 의미하며, 엔트로피는 다음과 같이 데이터가 어떤 클래스에 속할 확률에 대한 기댓값으로 표현할 수 있다.
334 |
335 | $$
336 | E = - \sum^k_{i=1} p_i \log_2 (p_i)
337 | $$
338 |
339 | 엔트로피는 데이터가 서로 다른 클래스에 속하면 높고, 같은 클래스에 속하면 낮다. 다시 말하면 각각의 데이터가 특정 클래스에 속할 확률이 높고 나머지 클래스에 속할 확률이 낮다면 엔트로피가 낮고, 모든 각각의 클래스에 속할 확률이 비슷하다면 엔트로피는 높다.
340 |
341 | **정보이득**은 데이터가 어떤 클래스에 속할 확률이 커짐에 따라 정보를 잘 얻게되는 것을 말하며, 감소되는 엔트로피 양을 의미한다. 수식으로는 기존 시스템의 엔트로피에서 현재 엔트로피를 뺀 값으로 표현된다. 의사결정트리는 가지를 칠 때 이 값을 사용하여 가지를 친다. 이 때 어떤 데이터를 두 집합으로 나누었을 때 두 집합의 정보이득이 크도록, 엔트로피는 작아지도록 분할을 한다.
342 |
343 | #### References
344 |
345 | - [10.1 엔트로피 - 데이터 사이언스 스쿨](https://datascienceschool.net/02%20mathematics/10.01%20%EC%97%94%ED%8A%B8%EB%A1%9C%ED%94%BC.html)
346 | - [[인공지능] 엔트로피(Entropy) 와 정보이득(Information Gain) 계산 - 꾸준희](https://eehoeskrap.tistory.com/13)
347 | - [파이썬 머신러닝 완벽 가이드 - 권철민](http://www.yes24.com/Product/Goods/87044746?OzSrank=2)
348 |
349 | ---
350 |
351 | ## #13
352 |
353 | ### 어떨 때 모수적 방법론을 쓸 수 있고, 어떨 때 비모수적 방법론을 쓸 수 있나요?
354 |
355 | 표본의 통계량(평균, 표준편차 등)을 통해 모집단의 모수(모평균, 모표준편차 등)를 추정하는 방법을 통계적 추론이라고 한다.
356 |
357 | 모집단이 어떤 분포를 따른다는 가정 하에 통계적 추론을 하는 방법을 모수적 방법이라 하는데, 표본의 수가 30개 이상일 때 중심극한 정리에 의해 정규분포를 따르므로 **모수적 방법론**을 사용한다.
358 |
359 | 반대로, 모집단의 분포를 가정하지 않는 비모수적 방법은, 표본의 수가 30개 미만이거나 정규성 검정에서 정규 분포를 따르지 않는다고 증명되는 경우 **비모수적 방법론**을 사용한다.
360 |
361 | #### References
362 |
363 | - [어떨 때 모수적 방법론을 쓸 수 있고, 어떨 때 비모수적 방법론을 쓸 수 있나요? - 내가 보려고 만든 공간](https://astralworld58.tistory.com/80)
364 |
365 | ---
366 |
367 | ## #14
368 |
369 | ### “likelihood”와 “probability”의 차이는 무엇일까요?
370 |
371 | 확률(Probability)은 어떤 시행(trial)에서 특정 결과(sample)가 나올 가능성을 말한다. 즉, 시행 전 모든 경우의 수의 가능성은 정해져 있으며 그 총합은 1(100%)이다.
372 |
373 | 가능도(Likelihood)은 어떤 시행(trial)을 충분히 수행한 뒤 그 결과(sample)를 토대로 경우의 수의 가능성을 도출하는 것을 말한다. 아무리 충분히 수행해도 어디까지나 추론(inference)이기 때문에 가능성의 합이 1이 되지 않을수도 있다.
374 |
375 | PDF(probability density function)에서는 **확률변수**를 변수로 보기 때문에 총합이 1이지만, likelihood function에서는 **분포의 모수**를 변수로 보기 때문에 총합이 1이 되지 않을수도 있다.
376 |
377 | #### References
378 |
379 | - [가능도(Likelihood)와 확률(Probability)의 차이 - JMAN's SW Lab.](https://swjman.tistory.com/104)
380 |
381 | ---
382 |
383 | ## #15
384 |
385 | ### 통계에서 사용되는 bootstrap의 의미는 무엇인가요.
386 |
387 | **부트스트랩(Bootstrap)** 은 가설검증을 하거나 metric을 계산하기 전에 random sampling을 적용하는 방법이다. 모수의 분포를 추정하는 방법 중 하나는, 현재 가진 표본에서 추가적으로 표본을 복원추출하고 각 표본에 대한 통계량을 다시 계산하는 것이다.
388 | 부트스트랩이 여기에 해당하며, 여러번의 무작위 추출을 통해, 평균의 신뢰구간을 구할 수 있다.
389 |
390 | 200개로만 통계량을 구하는 것이 아니라 200개를 기준으로 복원 추출하여 새로운 통계량을 구하는 것을 예시로 들 수 있다.
391 |
392 | > **머신러닝에서 부트스트램의 의미**
393 |
394 | 머신러닝에서 부트스트랩은 아래와 같이 해석될 수 있다.
395 |
396 | - 랜덤 샘플링을 통해 학습 데이터를 늘리는 방법
397 | - 여러 모델을 학습시켜 추론 결과의 평균을 사용하는 방법(=앙상블)
398 |
399 | > **복원추출이란?**
400 |
401 | 복원추출(Sampling with replacement)이란 확률을 구할 때, 추출했던 것을 원래대로 돌려놓고 다시 추출하는 방법을 말한다.
402 |
403 | #### References
404 |
405 | - [부트스트랩에 대하여 - Learning Carrot](https://learningcarrot.wordpress.com/2015/11/12/%EB%B6%80%ED%8A%B8%EC%8A%A4%ED%8A%B8%EB%9E%A9%EC%97%90-%EB%8C%80%ED%95%98%EC%97%AC-bootstrapping/)
406 | - [DATA - 12. 부트스트랩](https://bkshin.tistory.com/entry/DATA-12)
407 | - [복원추출 - 사이언스올](https://www.scienceall.com/%EB%B3%B5%EC%9B%90-%EC%B6%94%EC%B6%9Csampling-with-replacement/)
408 |
409 | ---
410 |
411 | ## #16
412 |
413 | ### 모수가 매우 적은 (수십개 이하) 케이스의 경우 어떤 방식으로 예측 모델을 수립할 수 있을까요?
414 |
415 | > _모수는 모집단의 수가 아닌, 평균, 표준편차 등의 모집단의 특징을 말합니다. 여기서는 모집단의 수로 잘못 쓰인 것으로 보이며, 데이터가 적은 경우라 가정하고 답변을 작성하였습니다._
416 |
417 | 표본이 매우 작은 경우 표본평균의 분포가 정규분포를 따른다고 가정할 수 없으므로 **비모수적 방법**을 채택하여 예측 모델을 수립할 수 있다. 하지만 중심극한정리에 의해 표본의 크기가 30보다 클 경우 표본평균이 정규분포를 따른다고 가정할 수 있으므로, 이 경우에는 모수적 방법을 사용한다.
418 |
419 | #### References
420 |
421 | - [모수, 큰 수의 법칙, 그리고 중심극한정리 - Kyoyoung Chu](https://chukycheese.github.io/data%20science/parameter-clt/)
422 | - [퍼널에서 모수 용어 질문요? - 인프런, cco](https://www.inflearn.com/questions/34568)
423 | - [[통계이론] 모수적 방법 vs 비모수적 방법](https://zzanhtt.tistory.com/18)
424 |
425 | ---
426 |
427 | ## #17
428 |
429 | ### 베이지안과 프리퀀티스트 간의 입장차이를 설명해주실 수 있나요?
430 |
431 | 베이지안은 사건의 확률을 바라볼 때, 사전 확률을 미리 염두해두고 사건의 발생에 따라 베이즈 정리로 사후 확률을 구해 다시 사전 확률을 업데이트시킨다. 즉, 베이지안은 **과거의 사건이 현재 사건에 영향을 끼친다는 입장**을 가지고 있다.
432 |
433 | 반면, 프리퀀티스트는 확률을 무한번 실험한 결과, 객관적으로 발생하는 현상의 빈도수로 바라본다. 즉, 프리퀀티스트는 **현재의 객관적인 확률에 의해서만 사건이 발생한다는 입장**을 가지고 있다.
434 |
435 | #### References
436 |
437 | - [베이지안(Bayesian)과 프리퀀티스트(Frequentist) 간의 입장 차이 - 내가 보려고 만든 공간](https://astralworld58.tistory.com/81)
438 |
439 | ---
440 |
441 | ## #18
442 |
443 | ### 검정력(statistical power)은 무엇일까요?
444 |
445 | | | 귀무가설 H0 참 | 귀무가설 H0 거짓 |
446 | | :--------------: | :------------: | :--------------------: |
447 | | 귀무가설 H0 채택 | 옳은 결정(1-α) | 제 2종 오류(β) |
448 | | 귀무가설 H0 기각 | 제 1종 오류(α) | 옳은 결정(1-β), 검정력 |
449 |
450 | 검정력은 대립가설 H1이 참인 경우 귀무가설 H0를 기각(대립가설 H1을 채택)할 확률이다.
451 |
452 | 
453 |
454 | #### References
455 |
456 | - [검정력(power)의 의미 및 수식 -
457 | Curycu's Box](https://m.blog.naver.com/PostView.nhn?blogId=hancury&logNo=220854934914&proxyReferer=https:%2F%2Fwww.google.com%2F)
458 | - [통계적 검정: 검정력(power)과 Type 1, 2 Error(1, 2 종 오류) - 코딩하고, ](https://niceguy1575.tistory.com/entry/%ED%86%B5%EA%B3%84%EC%A0%81-%EA%B2%80%EC%A0%95-%EA%B2%80%EC%A0%95%EB%A0%A5power%EA%B3%BC-Type-1-2-Error1-2-%EC%A2%85-%EC%98%A4%EB%A5%98)
459 |
460 | ---
461 |
462 | ## #19
463 |
464 | ### missing value가 있을 경우 채워야 할까요? 그 이유는 무엇인가요?
465 |
466 | missing value를 처리하는 방법에는 크게 4가지가 있다.
467 |
468 | 1. `그대로 놔두기`: 누락된 데이터를 그대로 놔두는 방법이다.
469 | 2. `삭제하기`: 누락된 데이터를 제거하는 방법이다. 그러나 중요한 정보를 가진 데이터를 잃을 위험이 있다.
470 | 3. `특정 값으로 채우기`: 0, 빈번한 값, 지정한 상수값으로 채우기
471 | 4. `예측하여 채우기`: K-means, 평균값, 중앙값으로 대체하는 것
472 |
473 | 1번 방법을 사용하여, 데이터가 누락된 채로 놔둔다고 가정하자.
474 | 일부 xgboost같은 알고리즘은 결측값을 고려하여 잘 학습한다.
475 | 그러나 **결측치를 처리하는 로직이 없는 알고리즘(ex. sklearn의 LinearRegression)은 누락된 데이터 때문에 엉망이 될 수 있다.**
476 | 따라서 결측치를 처리해주어야한다.
477 |
478 | 2번 방법을 사용하여, 누락된 데이터를 제거한다고 해보자. 제거하는 방법은 가장 쉬운 방법이다. 그러나 만약 100명 중 한명의 특징(feature)이 누락된 상태이므로, 해당 특징을 전부 삭제한다면 중요한 특성을 잃어버리는 결과를 초래하게 된다.
479 |
480 | 3번, 4번 방법을 사용하여 결측치를 채운다고 해보자. 결측치를 채움으로서, 중요한 정보를 잃지않고 특성을 유지할 수 있다. 그러나 만약 100명 중 99명의 특징이 누락된 상태라고 한다면, 해당 특징을 어떠한 값으로 채우는 행위가 무의미할 것이다.
481 |
482 | 따라서 **결측치 상태나 비율, 어떤 모델을 사용할 것인지**에 따라서 결측치 대응 방법이 달라질 수 있다.
483 |
484 | #### References
485 |
486 | - [누락 데이터(Missing value)를 처리하는 7가지 방법 - 밥먹는 개발자](https://dining-developer.tistory.com/19)
487 |
488 | ---
489 |
490 | ## #20
491 |
492 | ### 아웃라이어의 판단하는 기준은 무엇인가요?
493 |
494 | 이상치(outlier)는 전체 데이터의 패턴에서 벗어난 이상한 값을 가진 데이터를 말한다. 이상치는 모델의 성능에 영향을 미치므로 이를 탐지하는 것은 정말 중요하다.
495 |
496 | 이상치를 탐지하는 방법 중 하나로 **IQR(Inter Quantile Range) 기법**이 있다. IQR 기법을 사용하기 위해서는 우선 데이터를 오름차순으로 정렬하고 25%, 50%, 75%, 100%로 4등분을 한다. 이 75% 지점과 25% 지점의 값의 차이를 IQR이라고 한다. 이 IQR에 1.5를 곱한 값을 75% 지점의 값에 더하여 최대값을, 25% 지점의 값에서 빼서 최소값을 계산한다. 이 때 최소값보다 작거나 최대값보다 큰 값을 이상치라고 판단한다.
497 |
498 | 또 다른 탐지 방법으로는 **Z-score를 계산하는 방식**이 있다. Z-score는 데이터가 평균에서 얼마나 떨어져 있는지를 나타내는 지표로, 임계값을 설정하여 Z-score이 이 값보다 크다면 이상치로 판단한다. 하지만 Z-score 방식은 데이터가 가우시안 분포를 따른다고 가정하기 때문에 데이터가 가우시안 분포가 아닐 경우 별도의 변환이 필요하다.
499 |
500 | #### References
501 |
502 | - [A Brief Overview of Outlier Detection Techniques - Towards Data Science](https://towardsdatascience.com/a-brief-overview-of-outlier-detection-techniques-1e0b2c19e561)
503 | - [IQR 방식을 이용한 이상치 데이터(Outlier) 제거 - Hwi's ML doc](https://hwi-doc.tistory.com/entry/IQR-%EB%B0%A9%EC%8B%9D%EC%9D%84-%EC%9D%B4%EC%9A%A9%ED%95%9C-%EC%9D%B4%EC%83%81%EC%B9%98-%EB%8D%B0%EC%9D%B4%ED%84%B0Outlier-%EC%A0%9C%EA%B1%B0)
504 | - [[데이터전처리] Outlier(이상치/이상값/특이값/특이치 등) 탐지 방법(detection method) : 2. Z-score 방식 with - Clary K](https://claryk.tistory.com/5)
505 |
506 | ---
507 |
508 | ## #21
509 |
510 | ### 필요한 표본의 크기를 어떻게 계산합니까?
511 |
512 | 먼저 **모집단의 크기 $N$** 을 구하고, **신뢰수준 $z$** 와 **오차범위 $e$** 를 얼마로 할지 선정하여 표본의 크기를 구할 수 있다.
513 |
514 | $$
515 | \frac{\frac{z^2 \times p(1-p)}{e^2}}{1 + (\frac{z^2 \times p(1-p)}{e^2 N})}
516 | $$
517 |
518 | 참고로 신뢰수준은 표본추출을 반복했을 때 얼마나 그 결과를 신뢰할 수 있는지에 대한 정도로 95% 를 주로 사용한다.
519 |
520 | 오차범위는 작을 수록 모집단의 특성에 대한 유용한 정보를 제공하지만 모집단에 대한 추론이 틀릴 가능성도 높아지므로 10% 를 넘지 않게 한다.
521 |
522 | #### References
523 |
524 | - [필요한 설문 응답자수(표본크기) 계산하기 - LearnX](https://learnx.tistory.com/entry/%ED%95%84%EC%9A%94%ED%95%9C-%EC%84%A4%EB%AC%B8-%EC%9D%91%EB%8B%B5%EC%9E%90%EC%88%98%ED%91%9C%EB%B3%B8%ED%81%AC%EA%B8%B0-%EA%B3%84%EC%82%B0%ED%95%98%EA%B8%B0)
525 | - [표본크기의 결정 - Data Scream](https://datascream.co.kr/77)
526 |
527 | ---
528 |
529 | ## #22
530 |
531 | ### Bias를 통제하는 방법은 무엇입니까?
532 |
533 | 
534 |
535 | 편향(Bias)는 데이터 내에 있는 모든 정보를 고려하지 않음으로 인해, 지속적으로 잘못된 것들을 학습하는 경향을 의미한다. 이는 언더피팅(Underfitting)과 관계되어 있다.
536 |
537 | 반대로 분산(Variance)는 데이터 내에 있는 에러나 노이즈까지 잘 잡아내는 highly flexible models에 데이터를 피팅시킴으로써, 실제 현상과 관계 없는 랜덤한 것들까지 학습하는 알고리즘의 경향을 의미한다. 이는 오버피팅(Overfitting)과 관계되어 있다.
538 |
539 | 
540 |
541 | 편향(Bias)과 분산(Variance)은 한 쪽이 증가하면 다른 한 쪽이 감소하고, 한쪽이 감소하면 다른 한쪽이 증가하는 tradeoff 관계를 가진다.
542 |
543 | 
544 |
545 | **Bias를 통제하기 위한 방법**으로는 뉴런이나 계층의 개수가 같은 모델의 크기 증가, 오류평가시 얻은 지식을 기반으로 입력 특성 수정, 정규화, 모델 구조를 수정, 학습 데이터 추가 등의 방법이 있다.
546 |
547 | #### References
548 |
549 | - [쉽게 이해해보는 bias-variance tradeoff - 건빵의 블로그](https://bywords.tistory.com/entry/%EB%B2%88%EC%97%AD-%EC%9C%A0%EC%B9%98%EC%9B%90%EC%83%9D%EB%8F%84-%EC%9D%B4%ED%95%B4%ED%95%A0-%EC%88%98-%EC%9E%88%EB%8A%94-biasvariance-tradeoff)
550 | - [Bias and Variance (편향과 분산) - 한 페이지 머신러닝](https://opentutorials.org/module/3653/22071)
551 | - [[MLY] avoidable bias를 줄이는 방법들 - 생각많은 소심남](https://talkingaboutme.tistory.com/entry/MLY-avoidable-bias%EB%A5%BC-%EC%A4%84%EC%9D%B4%EB%8A%94-%EB%B0%A9%EB%B2%95%EB%93%A4?category=538748)
552 |
553 | ---
554 |
555 | ## #23
556 |
557 | ### 로그 함수는 어떤 경우 유용합니까? 사례를 들어 설명해주세요.
558 |
559 | 우선 **단위 수가 너무 큰 값들을 바로 회귀분석 할 경우 결과를 왜곡할 우려가 있으므로 이를 방지하기 위해 사용**된다.
560 |
561 | 예를들어, 나이와 재산보유액의 관계를 회귀분석으로 푼다고 했을 때, 재산보유액의 숫자가 굉장히 클 수 있다.
562 | 재산보유액에 로그를 취할 경우, 데이터의 왜도와 첨도를 줄일 수 있어 정규성이 높아지는 효과를 얻는다.
563 |
564 | 또한 **비선형관계의 데이터를 선형으로 만들기 위해** 사용된다.
565 |
566 | 예를들어, 기하급수적으로 늘어나는 제곱 형식의 그래프에 자연로그를 취하면 그 관계가 직선(선형)이 된다.
567 |
568 | > **로그함수 주의사항**
569 |
570 | 로그 함수는 0~1 사이에서는 음수값을 가지므로, $log(1+x)$와 같은 방법으로 처리해주어야한다.
571 |
572 | > **왜도(skewness)와 첨도(Kurtosis)**
573 |
574 | - 왜도는 데이터가 한쪽으로 치우친 정도이다.
575 | - 첨도는 분포가 얼마나 뾰족한지를 나타내는 정도이다.
576 |
577 | #### References
578 |
579 | - [로그함수를 취하는 이유 - 당도](https://dangdo.tistory.com/44)
580 |
581 | ---
582 |
583 | ## #24
584 |
585 | ### 베르누이 분포, 이항 분포, 카테고리 분포, 다항 분포, 가우시안 정규 분포, t 분포, 카이제곱 분포, F 분포, 베타 분포, 감마 분포에 대해 설명해주세요.
586 |
587 | - [answer/statistics-math-distribution.md](./statistics-math-distribution.md) 참고
588 |
589 | (TODO: 추후 수정)
590 |
591 | ---
592 |
593 | ## #25
594 |
595 | ### 출장을 위해 비행기를 타려고 합니다. 당신은 우산을 가져가야 하는지 알고 싶어 출장지에 사는 친구 3명에게 무작위로 전화를 하고 비가 오는 경우를 독립적으로 질문했습니다. 각 친구는 2/3로 진실을 말하고 1/3으로 거짓을 말합니다. 3명의 친구가 모두 “그렇습니다. 비가 내리고 있습니다”라고 말했습니다. 실제로 비가 내릴 확률은 얼마입니까?
596 |
597 | 
598 |
599 | 출장지에 비가 내릴 때 $p$, 내리지 않을 때를 $1-p$라고 하자. 출장지에 비가 내리는데( $p$ ) 모든 친구가 비가 내린다라고 한다면 모든 친구가 진실을 말하는 것( $\frac{8}{27}$ )이다. 이 경우 확률은 $\frac{8p}{27}$이다.
600 |
601 | 출장지가 비가 내리지 않는데( $(1-p)$ ) 모든 친구가 비가 내린다라고 한다면 모든 친구가 거짓을 말하는 것( $\frac{1}{27}$ )이다. 이 경우 확률은 $\frac{(1-p)}{27}$이다.
602 |
603 | 
604 |
605 | 위에서 계산한 확률을 위의 식에 대입하고 식을 정리하면 아래와 같다.
606 |
607 | $$
608 | Pr(raining | Yes) = \frac{\frac{8p}{27}}{\frac{8p}{27} + \frac{(1-p)}{27}} = \frac{8p}{8p + (1-p)} = \frac{8p}{7p+1}
609 | $$
610 |
611 | 만약 출장지에 비가 올 확률이 25%라면 실제로 출장지에 비가 내릴 확률은 약 72.7%이다.
612 |
613 | #### References
614 |
615 | - [페이스북 데이터 사이언스 직무 인터뷰 - glassdoor](https://www.glassdoor.com/Interview/You-re-about-to-get-on-a-plane-to-Seattle-You-want-to-know-if-you-should-bring-an-umbrella-You-call-3-random-friends-of-y-QTN_519262.htm)
616 | - [Solving Facebook's raining in Seattle interview question - Youtube](https://www.youtube.com/watch?v=NM91QI2uUqI)
617 |
--------------------------------------------------------------------------------
/answers/5-network.md:
--------------------------------------------------------------------------------
1 | > **📌 질문 중 일부는 [WeareSoft님의 tech-interview](https://github.com/WeareSoft/tech-interview)를 참고하였습니다.**
2 |
3 | ## Table of Contents
4 |
5 | - [TCP/IP의 각 계층을 설명해주세요.](#1)
6 | - [OSI 7계층와 TCP/IP 계층의 차이를 설명해주세요.](#2)
7 | - [Frame, Packet, Segment, Datagram을 비교해주세요.](#3)
8 | - [TCP와 UDP의 차이를 설명해주세요.](#4)
9 | - [TCP와 UDP의 헤더를 비교해주세요.](#5)
10 | - [TCP의 3-way-handshake와 4-way-handshake를 비교 설명해주세요.](#6)
11 | - [TCP의 연결 설정 과정(3단계)과 연결 종료 과정(4단계)이 단계가 차이나는 이유가 무엇인가요?](#7)
12 | - [만약 Server에서 FIN 플래그를 전송하기 전에 전송한 패킷이 Routing 지연이나 패킷 유실로 인한 재전송 등으로 인해 FIN 패킷보다 늦게 도착하는 상황이 발생하면 어떻게 될까요?](#8)
13 | - [초기 Sequence Number인 ISN을 0부터 시작하지 않고 난수를 생성해서 설정하는 이유가 무엇인가요?](#9)
14 | - [HTTP와 HTTPS에 대해서 설명하고 차이점에 대해 설명해주세요.](#10)
15 | - [HTTP 요청/응답 헤더의 구조를 설명해주세요.](#11)
16 | - [HTTP와 HTTPS 동작 과정을 비교해주세요.](#12)
17 | - [CORS가 무엇인가요?](#13)
18 | - [HTTP GET과 POST 메서드를 비교/설명해주세요.](#14)
19 | - [쿠키(Cookie)와 세션(Session)을 설명해주세요.](#15)
20 | - [DNS가 무엇인가요?](#16)
21 | - [REST와 RESTful의 개념을 설명하고 차이를 말해주세요.](#17)
22 | - [소켓(Socket)이 무엇인가요? 자신 있는 언어로 간단히 소켓 생성 예시를 보여주세요.](#18)
23 | - [Socket.io와 WebSocket의 차이를 설명해주세요.](#19)
24 | - [IPv4와 IPv6 차이를 설명해주세요.](#20)
25 | - [MAC Address가 무엇인가요?](#21)
26 | - [라우터와 스위치, 허브의 차이를 설명해주세요.](#22)
27 | - [SMTP가 무엇인가요?](#23)
28 | - [노트북으로 `www.google.com`에 접속을 했습니다. 요청을 보내고 받기까지의 과정을 자세히 설명해주세요.](#24)
29 | - [여러 네트워크 topology에 대해 간단히 소개해주세요.](#25)
30 | - [subnet mask에 대해서 설명해주세요.](#26)
31 | - [data encapsulation이 무엇인가요?](#27)
32 | - [DHCP를 설명해주세요.](#28)
33 | - [routing protocol을 몇 가지 설명해주세요. (ex. link state, distance vector)](#29)
34 | - [이더넷(ethernet)이 무엇인가요?](#30)
35 | - [client와 server의 차이점을 설명해주세요.](#31)
36 | - [delay, timing(jitter), throughput 차이를 설명해주세요.](#32)
37 |
38 | ---
39 |
40 | ## #1
41 |
42 | #### TCP/IP의 각 계층을 설명해주세요.
43 |
44 | TCP/IP는 인터넷에서 표준으로 사용되고 있는 네트워크 프로토콜(규칙)을 의미한다. TCP/IP는 IP(Internet Protocol)을 중심으로 한 여러 프로토콜의 집합체로, TCP/IP 5계층 혹은 TCP/IP 4계층(링크계층과 물리계층을 하나의 계층으로 보는 경우)으로 불린다.
45 |
46 | TCP/IP는 크게 5개의 계층으로 구성된다.
47 |
48 | > **애플리케이션 계층**(Application Layer, L5)
49 |
50 | 네트워크 애플리케이션과 애플리케이션 계층 프로토콜이 있는 곳이다. HTTP, SMTP, FTP와 같은 많은 프로토콜을 포함한다. 도메인 주소를 32비트 네트워크 주소로 변환하는 기능을 위한 DNS(Domain Name Server)를 지원한다. 애플리케이션 계층 패킷을 **메시지**(message)라고 한다.
51 |
52 | > **트랜스포트 계층**(Transport Layer, L4)
53 |
54 | 네트워크 계층에서 보내온 데이터 정렬, 오류 정정 등을 수행하고 신뢰할 수 있는 통신을 확보한다. TCP/UDP 같은 프로토콜이 이 계층에 위치한다. TCP, UDP에 대한 내용은 [[#4] TCP와 UDP의 차이를 설명해주세요.](#4) 을 참고한다. 트랜스포트 계층 패킷을 **세그먼트**(segment)라고 한다.
55 |
56 | > **네트워크 계층**(Network Layer/IP Layer, L3)
57 |
58 | 다른 네트워크에 있는 목적지에 데이터를 전송하는 역할을 수행한다. 즉, 네트워크 간의 통신을 가능하게 해주는 역할을 수행한다. 이를 위해, 라우터(router) 장비와 IP 프로토콜(오직 하나만 존재), 라우팅 프로토콜이 사용된다. 라우터는 다른 네트워크와 통신하기 위해 경로를 설정하고 논리주소를 결정하는 역할을 수행한다.(경로설정) 네트워크 계층의 패킷을 **데이터그램**(datagram)이라 한다.
59 |
60 | > **링크 계층**(Data Link Layer, L2)
61 |
62 | 네트워크 기기 간 데이터 전송 및 물리 주소를 결정하는 역할을 수행한다. 주로 건물이나 특정 지역을 범위로 하는 네트워크인 랜(LAN)에서 데이터를 정상적으로 주고받기 위해 필요한 계층이다. 데이터 링크 계층에서는 일반적으로 이더넷(Ethernet) 프로토콜이 사용되며, 스위치(switch) 같은 장치가 사용된다. 링크 계층 패킷을 **프레임**(frame)이라 한다.
63 |
64 | > **물리 계층**(Physical Layer, L1)
65 |
66 | 물리적인 연결과 전기 신호 변환/제어를 담당하여, 이진 데이터를 전기 신호로 변환한다. 또한 컴퓨터와 네트워크 장비를 물리적으로 연결하여, 하나의 노드에서 다른 노드로 **비트를** 이동시키는 역할을 수행한다. 물리 계층의 프로토콜들은 링크(실제 전송매체 ex.광케이블)에 의존한다.
67 |
68 | 
69 |
70 | #### References
71 |
72 | - [CH.01 컴퓨터 네트워크와 인터넷 - LandvibeDev/cs-special-forces-headquarters](https://github.com/LandvibeDev/cs-special-forces-headquarters/blob/main/network/CH.01%EC%BB%B4%ED%93%A8%ED%84%B0%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC%EC%99%80%EC%9D%B8%ED%84%B0%EB%84%B7/CH.01%20%EC%BB%B4%ED%93%A8%ED%84%B0%20%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC%EC%99%80%20%EC%9D%B8%ED%84%B0%EB%84%B7.md)
73 | - [[네트워크] TCP/IP 5계층에서 일어나는 일 (1) - 코알라일락's BLOG](https://zion830.tistory.com/104)
74 |
75 | ---
76 |
77 | ## #2
78 |
79 | #### OSI 7계층와 TCP/IP 계층의 차이를 설명해주세요.
80 |
81 | 
82 |
83 | (`네트워크 인터페이스 계층`: TCP/IP 5계층에서 물리계층과 링크계층을 하나로 묶은 것)
84 |
85 | OSI 7계층은 TCP/IP 계층의 애플리케이션 계층을 더 세분화한 것이다. TCP/IP 계층과 다른, 응용계층, 표현계층과 세션계층에 대해서 설명하고 나머지는 [[#1] CP/IP의 각 계층을 설명해주세요.](#1)을 참고한다.
86 |
87 | > **응용 계층**(Application Layer)
88 |
89 | 사용자 또는 애플리케이션이 네트워크에 접근할 수 있도록 해주는 계층이다. 사용자를 위한 인터페이스를 지원하며, 사용자에게 보이는 유일한 계층이다. 메일 전송, 인터넷 접속 등의 작업을 수행할 수 있다.
90 |
91 | > **표현 계층**(Presentation Layer)
92 |
93 | 응용계층으로부터 전달받거나 전송하는 데이터의 인코딩 및 디코딩이 이루어지는 계층이다. 응용 계층에서 데이터를 이해할 수 있도록, 응용프로그램에 맞춰 변환하게 된다. 예를들어, JPEG, TIFF, GIF, MPEG 등의 다양한 포맷을 구분하게 된다.
94 |
95 | > **세션 계층**(Session Layer)
96 |
97 | 응용프로세스가 통신을 관리하기 위한 방법을 정의한다. 네트워크상 양쪽의 연결을 관리/지속시키는 역할과 세션을 만들거나 없애는 역할을 담당하는 계층이다. 통신하는 사용자들을 동기화하고 오류복구를 진행한다. 통신연결은 포트를 기반으로 구성하여 연결되며, OS가 세션계층에 속한다.
98 |
99 | #### References
100 |
101 | - [네크워크의 기본 OSI7 계층 - reakwon 티스토리](https://reakwon.tistory.com/59?category=300675)
102 | - [IT관련 용어 - [OSI 7계층] 이란? - pst8627 블로그](https://blog.naver.com/PostView.nhn?blogId=pst8627&logNo=221670903384)
103 |
104 | ---
105 |
106 | ## #3
107 |
108 | #### Frame, Packet, Segment, Datagram을 비교해주세요. (TCP/IP 5계층 기준)
109 |
110 | - **Packet**: 컴퓨터 간에 데이터를 주고받을 때, 네트워크를 통해 전송되는 **데이터 조각**을 패킷이라고 부른다. 송신 측(애플리케이션)은 많은 양의 데이터를 한번에 보내는 것이 아니라, 일정 단위로 잘라서 보낸다. 각 계층에서 필요한 정보는 캡슐화/역캡슐화되어 전달되고, 수신 측은 받은 패킷을 다시 조립해서 사용한다.
111 | - **Segment**: Transport 계층(L4)에서 신뢰할 수 있는 통신을 구현하기 위한 헤더를 데이터(L5 계층 데이터)에 붙이는데, 이렇게 만들어진 패킷을 세그먼트라고 부른다.
112 | - **Datagram**: Network 계층(L3)에서 다른 네트워크와 통신하기 위한 헤더를 세그먼트(L4 계층 데이터)에 붙인것을 데이터그램, 데이터 세그먼트라고 부른다.
113 | - **Frame**: 데이터 링크 계층(L2)에서 물리적인 통신 채널을 열기 위해 패킷에 헤더와 트레일러를 붙인다. 트레일러는 데이터를 전달할 때 데이터 끝 부분에 붙이는 정보로, 주로 에러 검출에 사용된다.
114 |
115 | 
116 |
117 | > **왜 패킷을 잘라서 보낼까?**
118 |
119 | 많은 데이터를 한번에 보내게 되면, 데이터 손실의 가능성이 있으며, 대역폭(신호를 전송할 수 있는 주파수 범위)을 너무 많이 차지하게 되므로, 패킷의 흐름을 원활히 조절하기 위함이다.
120 |
121 | > **소켓(Socket), 포트(Port), 패킷(Packet)**
122 |
123 | **Port**는 프로세스를 식별하기 위해, 호스트 내부적으로 프로세스가 할당받는 고유한 값이다. 같은 호스트 내에서 서로 다른 프로세스가 같은 포트 넘버를 가질 수 있음, 대신 같은 소켓을 사용하지는 못한다. `accept()`를 통해 만들어지는 소켓에는 새로운 포트 번호가 할당되는 것이 아니라, 서버가 가지는 포트(웹서버 기준, 80)와 동일한 포트 번호를 가진다. 만약 지정된 포트 번호를 다른 소켓이 사용하고 있다면, `bind()` API는 에러를 리턴한다. 포트는 논리적인 접속장소이다.
124 |
125 | **Socket**은 프로세스로부터 네트워크로 데이터를 전달하는 출입구(인터페이스) 역할을 한다. `프로세스에서 소켓을 연다`고 표현하며, 수신 측 호스트의 트랜스포트 계층은 실제로 데이터(세그먼트)를 직접 프로세스로 전달하지 않고, 중간 매개자인 소켓에게 전달한다. 호스트에서는 하나 이상의 소켓이 존재할 수 있으므로 소켓은 고유의 식별자를 가지고 있어야한다. 같은 프로세스가 같은 포트를 가지고도 여러 개의 소켓을 열 수 있기 때문에, 소켓과 포트는 다른 개념이다.
126 |
127 | 요약하자면, **소켓**은 프로세스가 네트워크를 통해서 데이터를 주고받으려면 반드시 열어야 하는 창구 같은 것이고, **포트**는 프로세스 식별을 위해 하나의 호스트에서 프로세스에 할당하는 고유값이고, **패킷**은 네트워크 상의 데이터 조각을 말하는 것이다.
128 |
129 | > **캡슐화/역캡슐화**
130 |
131 | - **캡슐화**(Encapsulation): (데이터 송신 시)하위 계층으로 패킷을 보낼때, 하위계층에서 필요로하는 추가정보(메타데이터)를 헤더/트레일러에 추가하여 보내게된다.
132 | - **역캡슐화**(Decapsulation): 데이터 수신 시, 상위 계층으로 패킷을 전달하고, 전달된 패킷의 헤더를 차례대로 제거하면서 데이터를 얻게 된다.
133 |
134 | #### References
135 |
136 | - [패킷이란 무엇일까? 패킷의 정의와 구조 - Jay's Blog](https://enlqn1010.tistory.com/9)
137 | - [[네트워크] TCP/IP 5계층에서 일어나는 일 (1) - 코알라일락's BLOG](https://zion830.tistory.com/104)
138 |
139 | ---
140 |
141 | ## #4
142 |
143 | #### TCP와 UDP의 차이를 설명해주세요.
144 |
145 | TCP와 UDP는 모두 트랜스포트 계층(4계층)의 프로토콜이다. TCP와 UDP가 **공통적**으로 가지고 있는 기능은 아래와 같다.
146 |
147 | 1. **트랜스포트 다중화/역다중화 기능**(Transport Multiplexing/Demultiplexing): `호스트 대 호스트 전달`을 `프로세스 대 프로세스 전달`로 확장
148 | 2. **무결성 검사(오류검출)**: 헤더에 오류 검출 필드를 포함
149 |
150 | 이제 TCP와 UDP 각각에 대해 알아보자.
151 |
152 | **UDP**는 위의 가장 기본적인 두가지 기능만을 제공한다. UDP는 **비신뢰적인 서비스**로서, 프로세스에 의해서 전송된 데이터가 손상되지 않은채로 목적지에 도착하는 것을 보장하지 않는다. 또한 **비연결형 서비스**이며, 오류검출은 선택사항이다.
153 |
154 | UDP는 비연결형 서비스이므로 연결설정이 불필요하고 연결상태가 없다. 따라서 연결을 설정하기위한 어떠한 지연이 없고, 유지해야하는 정보가 없기 때문에 더 많은 클라이언트를 수용할 수 있다. 또한 UDP의 패킷 오버헤드(8 byte per segment)가 TCP(20 byte per segment)에 비해 더 작다는 장점이 있다. 그러나 혼잡제어를 사용하지 않아, 네트워크가 폭주상태에 빠지는 것을 막을 수 없다는 단점과 신뢰적이지 않으므로, 몇몇의 정보를 잃어버릴 수 있다는 단점이 존재한다.
155 |
156 | **TCP**는 가장 기본적인 두가지 기능도 제공하면서, 신뢰적인 데이터 전달(Reliable Data Transfer) 기능, 연결지향형 서비스, 혼잡제어(Congestion control) 등의 기능을 제공한다.
157 |
158 | **신뢰적인 데이터 전달**은 흐름제어, 순서번호, 확인응답, 타이머 등의 기술을 사용하여 프로세스에게 데이터가 순서대로 정확히 전달되도록 하는 역할을 한다. 종단 시스템 간에 IP의 비신뢰적인 서비스를 프로세스 사이의 신뢰적인 데이터 전송 서비스로 만들수 있으며, TCP에서의 오류검출은 필수사항이다. **혼잡제어**는 보내는 쪽(송신측)의 트래픽을 조절하여 스위치/링크의 혼잡을 방지하는 역할을 한다. 이는 특정 애플리케이션을 위해 제공하는 특정 서비스가 아니라, 전체를 위한 서비스로서, 혼잡한 네트워크 링크에서 각 TCP 연결이 링크의 대역폭을 공평하게 공유하여 통과하도록 해준다.
159 |
160 | 따라서, UDP는 속도증가와 지연 감소를 위해서 많이 사용되고, TCP는 신뢰성이 중요한 경우에 사용된다. 예를들어, UDP는 동영상 전송과 같이, 몇 프레임 정도 손실되어도 괜찮은 데이터 전송에 사용되고, TCP는 몇몇의 정보도 손실되어서는 안되는 애플리케이션에 이용된다.
161 |
162 | #### References
163 |
164 | - [CH.03 트랜스포트 계층 - cs-special-forces-headquarters](https://github.com/LandvibeDev/cs-special-forces-headquarters/blob/main/network/CH.03%ED%8A%B8%EB%9E%9C%EC%8A%A4%ED%8F%AC%ED%8A%B8%EA%B3%84%EC%B8%B5/CH.03%20%ED%8A%B8%EB%9E%9C%EC%8A%A4%ED%8F%AC%ED%8A%B8%20%EA%B3%84%EC%B8%B5.md)
165 |
166 | ---
167 |
168 | ## #5
169 |
170 | #### TCP와 UDP의 헤더를 비교해주세요.
171 |
172 | **UDP segment**의 간략한 구조는 아래와 같다.
173 |
174 | 
175 |
176 | 애플리케이션 데이터는 UDP 데이터그램의 데이터 필드에 위치한다. UDP 헤더는 2바이트(16비트)씩 구성된 4개의 필드를 가진다. UDP 헤더는 `출발지 포트번호`, `목적지 포트번호`, `체크섬`, `길이`로 이루어져있다.
177 |
178 | - **포트번호**는 (목적지) 호스트가 (역다중화 기능을 수행하는) 정확한 프로세스에게 애플리케이션 데이터를 넘기게 하기 위해 사용된다.
179 | - **체크섬**(checksum)은 세그먼트에 오류가 발생했는지를 검사하기 위해 사용되며, 체크섬은 UDP 세그먼트 이외에 IP 헤더의 일부 필드도 계산한다.(가상헤더) UDP 헤더와 데이터를 모두 포함하여 체크하게 된다.
180 | - **길이**는 헤더를 포함하는 UDP 세그먼트의 길이(바이트 단위)를 나타낸다. UDP헤더와 데이터를 합친 길이를 나타낸다.
181 |
182 | ---
183 |
184 | **TCP segment**의 간략한 구조는 아래와 같다.
185 |
186 | 
187 |
188 | TCP 소켓은 4개의 다른 요소들의 집합에 의해 식별된다.(`출발지 IP`, `출발지 포트번호`, `목적지 IP`, `목적지 포트번호`) 따라서 IP를 제외한 `출발지/도착지 포트번호`(각 16 bit)와 `sequence number`(32 bit), `ack number`(32 bit)를 합쳐, 기본적으로 20 byte의 헤더를 가지게 되며, 옵션을 포함하면 최대 60 byte의 헤더를 가질 수 있다. 다른 출발지 주소를 가지는 세그먼트는, 다른 소켓을 통해서 프로세스에 전달된다. UDP와 다르게, TCP 세그먼트는 출발지 주소가 다르면, 다른 소켓으로 전달된다.
189 |
190 | - **포트번호**는 IP 정보와 결합하여 출발지, 도착지를 구분하기 위해 사용된다.
191 | - **Sequence Number**는 SYN 패킷을 보낼때, 동기화를 위해 사용되는 번호이다. 초기 Sequence Number를 ISN이라 부르며, 여기에는 랜덤한 수가 담긴다.
192 | - **Ack Number**는 ACK 패킷을 보낼 때 동기화를 위해 사용되는 번호이다.
193 |
194 | #### References
195 |
196 | - [CH.03 트랜스포트 계층 - cs-special-forces-headquarters](https://github.com/LandvibeDev/cs-special-forces-headquarters/blob/main/network/CH.03%ED%8A%B8%EB%9E%9C%EC%8A%A4%ED%8F%AC%ED%8A%B8%EA%B3%84%EC%B8%B5/CH.03%20%ED%8A%B8%EB%9E%9C%EC%8A%A4%ED%8F%AC%ED%8A%B8%20%EA%B3%84%EC%B8%B5.md)
197 |
198 | ---
199 |
200 | ## #6
201 |
202 | #### TCP의 3-way-handshake와 4-way-handshake를 비교 설명해주세요.
203 |
204 | **핸드셰이크**(Handshake)란, 호스트 간 데이터를 전송하기 전에 먼저 정확한 전송을 보장하기 위해 상대방 컴퓨터와 사전에 세션을 수립하는 과정을 의미한다.
205 |
206 | 
207 |
208 | **3-way handshake**는 TCP의 연결을 초기화 할 때 사용한다. 양쪽 모두 데이터를 전송할 준비가 되었다는 것을 보장하고, 실제로 데이터 전달이 시작하기전에 한쪽이 다른 쪽이 준비되었다는 것을 알수 있도록 한다. 양쪽 모두 상대편에 대한 초기 순차일련변호를 얻을 수 있도록 한다. 절차는 다음과 같다.
209 |
210 | 1. 접속 요청 프로세스가 연결 요청 메시지 전송한다.(SYN)
211 | 2. 접속 요청을 받은 프로세스가 요청을 수락한다는 확인 메시지를 보낸다. (ACK) 동시에 접속 요청을 받은 프로세스도 접속 요청을 한 프로세스에 연결 요청을 보낸다.(SYN) → (SYN + ACK)
212 | 3. 마지막으로 접속 요청 프로세스가 수락 확인을 보내 연결을 맺는다.(ACK)
213 |
214 | 단순히 응답을 주고받는데 2-way Handshake면 충분해보이지 않는가? 왜 3-way 일까? TCP/IP 통신은 양방향성 connection이다. 위의 그림의 1번 과정에서 클라이언트가 연결 요청을 SYN으로 보내면, 서버는 클라이언트가 요청한 SYN에 대한 대답(ACK)과 함께, 자신도 연결하겠다는 요청의 의미로 SYN을 보내고, 클라이언트로부터 요청에 대한 대답(과정 3)을 받아야한다. 이 과정은 2-way handshaked에서는 성립될 수 없다.
215 |
216 | 
217 |
218 | **4-way handshake**는 세션을 종료하기 위해 수행되는 절차이다. 구체적인 과정은 다음과 같다.
219 |
220 | 1. 클라이언트가 연결을 종료하겠다는 FIN 플래그를 전송한다.
221 | 2. 서버는 일단 확인메시지를 보내고 자신의 통신이 끝날때까지 기다리는데, 이 상태가 `TIME_WAIT` 상태이다.
222 | 3. 서버가 통신이 끝났으면 연결이 종료되었다고 클라이언트에게 FIN 플래그를 전송한다.
223 | 4. 클라이언트는 확인했다는 메시지를 보낸다.
224 |
225 | > **💡 `CLOSE_WAIT` 와 `TIME_WAIT` 상태란 무엇일까?**
226 | > `TIME_WAIT` 상태로 대기하는 이유는, 세션 종료후, 혹시나 네트워크에 아직 라이브 패킷이 존재할수도 있기때문이다.
227 |
228 | > **💡 용어**
229 | >
230 | > - **SYN**(Synchronization): 연결요청, 세션을 설정하는데 사용되며 초기에 시퀀스 번호를 보낸다.
231 | > - **ACK**(Acknowledgement): 보낸 시퀀스 번호에 TCP 계층에서의 길이 또는 양을 더한 것과 같은 값을 ACK에 포함하여 전송한다.
232 | > - **FIN**(Finish) : 세션을 종료시키는데 사용되며 더 이상 보낸 데이터가 없음을 표시한다.
233 |
234 | #### References
235 |
236 | - [[네트워크] 3-way / 4-way Handshake 란? - 방구의 개발냄새](https://bangu4.tistory.com/74)
237 | - [TCP의 3 way Handshake과 4 way Handshake - 자비스가 필요해](https://needjarvis.tistory.com/157)
238 | - [3-way handshake 4-way handshake는 왜 필요할까? - 안 평범한 개발자의 하루](https://unordinarydays.tistory.com/172)
239 |
240 | ---
241 |
242 | ## #7
243 |
244 | #### TCP의 연결 설정 과정(3단계)과 연결 종료 과정(4단계)이 단계가 차이나는 이유가 무엇인가요?
245 |
246 | 연결 설정 과정과 다르게, 연결 종료 과정에서 고려해야하는 경우가 존재하는데, 이는 전송중인 데이터에 대한 경우이다. 클라이언트는 아직 서버로부터 못 받은 데이터가 있을 것을 대비하여 일정시간동안 세션을 남긴다(`TIME_WAIT`). 모든 데이터를 다 보내서 더 이상 보낼 데이터가 없다는 의미의 `FIN`을 받으면, 바로 연결을 종료한다.
247 |
248 | #### References
249 |
250 | - [[네트워크] TCP의 연결과 종료 : 3-way-handshake & 4-way-handshake - cherishee](https://hee96-story.tistory.com/101)
251 |
252 | ---
253 |
254 | ## #8
255 |
256 | #### 만약 Server에서 FIN 플래그를 전송하기 전에 전송한 패킷이 Routing 지연이나 패킷 유실로 인한 재전송 등으로 인해 FIN 패킷보다 늦게 도착하는 상황이 발생하면 어떻게 될까요?
257 |
258 | 클라이언트에서 세션을 종료시킨 후 뒤늦게 도착하는 패킷이 있다면 이 패킷은 Drop되고 **데이터는 유실**될 것이다.
259 |
260 | A 클라이언트는 이러한 현상에 대비하여 Client는 Server로부터 `FIN`을 수신하더라도 일정시간동안 세션을 남겨놓고 잉여 패킷을 기다리는 과정을 거치게 되는데 이 과정을 `TIME_WAIT` 라고 한다. 일정시간이 지나면, 세션을 만료하고 연결을 종료시키며, `CLOSE` 상태로 변화한다.
261 |
262 | #### References
263 |
264 | - [[네트워크] 3-way / 4-way Handshake 란? - 방구의 개발냄새](https://bangu4.tistory.com/74)
265 |
266 | ---
267 |
268 | ## #9
269 |
270 | #### 초기 Sequence Number인 ISN을 0부터 시작하지 않고 난수를 생성해서 설정하는 이유가 무엇인가요?
271 |
272 | Connection을 맺을 때 사용하는 포트는 유한 범위 내에서 사용하고 시간이 지남에 따라 재사용된다.
273 |
274 | 따라서 두 통신 호스트가 과거에 사용된 포트 번호 쌍을 사용하는 가능성이 존재한다.
275 |
276 | 서버 측에서는 패킷의 SYN을 보고 패킷을 구분하게 되는데 난수가 아닌 순차적인 number가 전송된다면 이전의 connection으로부터 오는 패킷으로 인식할 수 있다.
277 |
278 | 이러한 문제가 발생할 가능성을 줄이기 위해서 난수로 ISN을 설정하는 것이다.
279 |
280 | #### References
281 |
282 | - [[Network] (TCP) 3-way-handshake & 4-way-handshake - 어제보다 한 걸음 더](https://k39335.tistory.com/21)
283 |
284 | ---
285 |
286 | ## #10
287 |
288 | #### HTTP와 HTTPS에 대해서 설명하고 차이점에 대해 설명해주세요.
289 |
290 | HTTP란 **서버/클라이언트 모델을 따라 데이터를 주고받기 위한 프로토콜**이다. 즉, HTTP는 인터넷에서 하이퍼텍스트를 교환하기 위한 통신 규약으로, 80번 포트를 사용하고 있다. 따라서 HTTP 서버가 80번 포트에서 요청을 기다리고 있으며, 클라이언트는 80번 포트로 요청을 보내게 된다.
291 |
292 | HTTP는 1989년 팀 버너스 리(Tim Berners Lee)에 의해 처음 설계되었으며, WWW(World-Wide-Web) 기반에서 세계적인 정보를 공유하는데 큰 역할을 하였다.
293 |
294 | HTTPS는 **HTTP에 데이터 암호화가 추가된 프로토콜**이다. HTTPS는 HTTP와 다르게 443번 포트를 사용하며, 네트워크 상에서 중간에 제3자가 정보를 볼 수 없도록 공개키 암호화를 지원하고 있다.
295 |
296 | HTTP는 암호화가 추가되지 않았기 때문에 보안에 취약한 반면, HTTPS는 안전하게 데이터를 주고받을 수 있다. 하지만 HTTPS를 이용하면 암호화/복호화의 과정이 필요하기 때문에 HTTP보다 속도가 느리다. 또한 HTTPS는 인증서를 발급하고 유지하기 위한 추가 비용이 발생하다.
297 |
298 | 개인 정보와 같은 민감한 데이터를 주고받아야 한다면 HTTPS를 이용해야 하지만, 단순한 정보 조회 등 만을 처리하고 있다면 HTTP를 이용하면 된다.
299 |
300 | #### References
301 |
302 | - [[Web] HTTP와 HTTPS 및 차이점 - MangKyu's Diary](https://mangkyu.tistory.com/98)
303 |
304 | ---
305 |
306 | ## #11
307 |
308 | #### HTTP 요청/응답 헤더의 구조를 설명해주세요.
309 |
310 | (TODO: 답변 작성하기)
311 |
312 | #### References
313 |
314 | - [HTTP 구조 및 핵심 요소 - teddybearjung](https://velog.io/@teddybearjung/HTTP-%EA%B5%AC%EC%A1%B0-%EB%B0%8F-%ED%95%B5%EC%8B%AC-%EC%9A%94%EC%86%8C)
315 | - [[네트워크] http 란 - 인생의 로그캣](https://noahlogs.tistory.com/34?category=827412)
316 | - [HTTP 메시지 - MDN Web Docs](https://developer.mozilla.org/ko/docs/Web/HTTP/Messages)
317 |
318 | ---
319 |
320 | ## #12
321 |
322 | #### HTTP와 HTTPS 동작 과정을 비교해주세요.
323 |
324 | (TODO: 답변 추가하기)
325 |
326 | #### References
327 |
328 | - [HTTP & DNS & TCP 정의 및 동작원리 - lkh's](https://lkhlkh23.tistory.com/76)
329 | - [[Web 기초] HTTP 통신 과정 - MYSTERICO BLOG](https://mysterico.tistory.com/29)
330 | - [[Web 기초] HTTPS의 동작 원리 (feat. 와이어샤크) - MYSTERICO BLOG](https://mysterico.tistory.com/30)
331 |
332 | ---
333 |
334 | ## #13
335 |
336 | #### CORS가 무엇인가요?
337 |
338 | 교차 출처 리소스 공유(Cross-Origin Resource Sharing, CORS)는 **추가 HTTP 헤더를 사용하여, 한 출처에서 실행 중인 웹 애플리케이션이 다른 출처의 선택한 자원에 접근할 수 있는 권한을 부여하도록 브라우저에 알려주는 체제**이다.
339 |
340 | CORS 체제는 브라우저와 서버 간의 안전한 교차 출처 요청 및 데이터 전송을 지원한다. 최신 브라우저는 XMLHttpRequest 또는 Fetch와 같은 API에서 CORS를 사용하여 교차 출처 HTTP 요청의 위험을 완화한다.
341 |
342 | > **CORS의 동작 원리**
343 |
344 | 1. 기본적으로 웹은 다른 출처의 리소스를 요청할 때는 HTTP 프로토콜을 사용하여 요청을 하는데, 이때 브라우저는 요청 헤더 (request header)에 `Origin` 필드에 요청을 보내는 출처를 담아 전송한다.
345 | 2. 서버는 요청에 대한 응답을 하는데, 응답 헤더(response header)에 `Access-Control-Allow-Origin`이라는 값에 '이 리소스를 접근하는 것이 허용된 출처'를 내려준다.
346 | 3. 이후 응답을 받은 브라우저는 자신이 보냈던 요청의 Origin과 서버가 보내준 응답의 `Access-Control-Allow-Origin`을 비교해 본 후 이 응답이 유효한 응답인지 아닌지를 결정한다.
347 |
348 | 
349 |
350 | #### References
351 |
352 | - [CORS란 무엇인가 ? - pilyeooong.log](https://velog.io/@pilyeooong/CORS%EB%9E%80-%EB%AC%B4%EC%97%87%EC%9D%B8%EA%B0%80)
353 | - [교차 출처 리소스 공유 - 위키백과](https://ko.wikipedia.org/wiki/%EA%B5%90%EC%B0%A8_%EC%B6%9C%EC%B2%98_%EB%A6%AC%EC%86%8C%EC%8A%A4_%EA%B3%B5%EC%9C%A0)
354 |
355 | ---
356 |
357 | ## #14
358 |
359 | #### HTTP GET과 POST 메서드를 비교/설명해주세요.
360 |
361 | > **GET**
362 |
363 | GET은 **클라이언트에서 서버로 어떠한 리소스로부터 정보를 요청하기 위해 사용되는 메서드**이다. GET을 통한 요청은 URL 주소 끝에 파라미터로 포함되어 전송되며, 이 부분을 쿼리 스트링(query string)이라고 부른다.
364 |
365 | 방식은 URL 끝에 `?`를 붙이고 그다음 `변수명1=값1&변수명2=값2...` 형식으로 이어 붙이면 된다. 예를 들면 `www.example.com/show?name1=value1&name2=value2`이다. 서버에서는 `name1`과 `name2`라는 파라미터 명으로 각각 `value1`과 `value2`의 파라미터 값을 전달받을 수 있다.
366 |
367 | > **POST**
368 |
369 | POST는 **클라이언트에서 서버로 리소스를 생성하거나 업데이트하기 위해 데이터를 보낼 때 사용되는 메서드**이다. POST는 전송할 데이터를 HTTP 메시지 body 부분에 담아서 서버로 보낸다.(body의 타입은 Content-Type 헤더에 따라 결정된다.)
370 |
371 | GET에서 URL의 파라미터로 보냈던 `name1=value1&name2=value2`가 body에 담겨 보내진다 생각하면 된다. POST로 데이터를 전송할 때 길이 제한이 따로 없어 용량이 큰 데이터를 보낼 때 사용하거나 GET처럼 데이터가 외부적으로 드러나는 건 아니라서 보안이 필요한 부분에 많이 사용된다. POST를 통한 데이터 전송은 보통 HTML form을 통해 서버로 전송된다.
372 |
373 | > **GET과 POST의 차이점**
374 |
375 | - 사용목적: GET은 서버의 리소스에서 데이터를 요청할 때, POST는 서버의 리소스를 새로 생성하거나 업데이트할 때 사용한다.
376 | - 요청에 body 유무: GET은 URL 파라미터에 요청하는 데이터를 담아 보내기 때문에 HTTP 메시지에 body가 없다. POST는 body에 데이터를 담아 보내기 때문에 당연히 HTTP 메시지에 body가 존재한다.
377 | - 멱등성(idempotent): GET 요청은 멱등이며, POST는 멱등이 아니다.
378 |
379 | > **💡멱등이란?**
380 | > 멱등의 사전적 정의는 연산을 여러 번 적용하더라도 결과가 달라지지 않는 성질을 의미한다. GET은 리소스를 조회한다는 점에서 여러 번 요청하더라도 응답이 똑같을 것이다. 반대로 POST는 리소스를 새로 생성하거나 업데이트할 때 사용되기 때문에 멱등이 아니라고 볼 수 있다.(POST 요청이 발생하면 서버가 변경될 수 있다.)
381 |
382 | #### References
383 |
384 | - [[네트워크] get 과 post 의 차이 - 인생의 로그캣](https://noahlogs.tistory.com/35)
385 |
386 | ---
387 |
388 | ## #15
389 |
390 | #### 쿠키(Cookie)와 세션(Session)을 설명해주세요.
391 |
392 | > 쿠키(Cookie)
393 |
394 | 쿠키는 **클라이언트(브라우저) 로컬에 저장되는 키와 값이 들어있는 작은 데이터 파일**이다. 사용자 인증이 유효한 시간을 명시할 수 있으며, 유효 시간이 정해지면 브라우저가 종료되어도 인증이 유지된다는 특징이 있다.
395 |
396 | 쿠키는 클라이언트의 상태 정보를 로컬에 저장했다가 참조하며, Response Header에 Set-Cookie 속성을 사용하면 클라이언트에 쿠키를 만들 수 있다.
397 |
398 | 쿠키는 사용자가 따로 요청하지 않아도 브라우저가 Request 시에 Request Header를 넣어서 자동으로 서버에 전송한다.
399 |
400 | 쿠키는 다음과 같이 동작한다.
401 |
402 | 1. 클라이언트가 페이지를 요청
403 | 2. 서버에서 쿠키를 생성
404 | 3. HTTP 헤더에 쿠키를 포함 시켜 응답
405 | 4. 브라우저가 종료되어도 쿠키 만료 기간이 있다면 클라이언트에서 보관
406 | 5. 같은 요청을 할 경우 HTTP 헤더에 쿠키를 함께 보냄
407 | 6. 서버에서 쿠키를 읽어 이전 상태 정보를 변경할 필요가 있을 때 쿠키를 업데이트하여 변경된 쿠키를 HTTP 헤더에 포함시켜 응답
408 |
409 | > 세션(Session)
410 |
411 | 세션은 쿠키를 기반하고 있지만, 사용자 정보 파일을 브라우저에 저장하는 쿠키와 달리 세션은 **서버 측에서 관리**한다. 서버에서는 클라이언트를 구분하기 위해 세션 ID를 부여하며 웹 브라우저가 서버에 접속해서 브라우저를 종료할 때까지 인증 상태를 유지한다.
412 |
413 | 접속 시간에 제한을 두어 일정 시간 응답이 없다면 정보가 유지되지 않게 설정이 가능하다.
414 | 사용자에 대한 정보를 서버에 두기 때문에 쿠키보다 보안에 좋지만, 사용자가 많아질수록 서버 메모리를 많이 차지하게 된다. 즉 동접자 수가 많은 웹 사이트인 경우 서버에 과부하를 주게 되므로 성능 저하의 요인이 된다.
415 |
416 | 클라이언트가 Request를 보내면, 해당 서버의 엔진이 클라이언트에게 유일한 ID를 부여하는 데 이것이 세션 ID다.
417 |
418 | 세션의 동작 방식은 다음과 같다.
419 |
420 | 1. 클라이언트가 서버에 접속 시 세션 ID를 발급
421 | 2. 클라이언트는 세션 ID에 대해 쿠키를 사용해서 저장하고 가지고 있음
422 | 3. 클라이언트는 서버에 요청할 때, 이 쿠키의 세션 ID를 서버에 전달해서 사용
423 | 4. 서버는 세션 ID를 전달받아서 별다른 작업 없이 세션 ID로 세션에 있는 클라언트 정보를 가져옴
424 | 5. 클라이언트 정보를 가지고 서버 요청을 처리하여 클라이언트에게 응답
425 |
426 | > **쿠키와 세션의 차이점**
427 |
428 | - **사용자의 정보가 저장되는 위치**: 쿠키는 서버의 자원을 전혀 사용하지 않으며, 세션은 서버의 자원을 사용한다.
429 | - **보안**: 쿠키는 클라이언트 로컬에 저장되기 때문에 변질되거나 request에서 스니핑 당할 우려가 있어서 보안에 취약하다. 반면 세션은 쿠키를 이용해서 세션 ID만 저장하고 그것으로 구분해서 서버에서 처리하기 때문에 비교적 보안성이 좋다.
430 | - **라이프 사이클**: 쿠키는 만료시간이 있지만 파일로 저장되기 때문에 브라우저를 종료해도 계속해서 정보가 남아 있을 수 있다. 또한 만료 기간을 넉넉하게 잡아두면 쿠키 삭제를 할 때까지 유지될 수도 있다. 반면에 세션도 만료시간을 정할 수 있지만 브라우저가 종료되면 만료시간에 상관없이 삭제된다.
431 | - **속도**: 쿠키에 정보가 있기 때문에 서버에 요청 시 속도가 빠르다. 반면 세션은 정보가 서버에 있기 때문에 처리가 요구되어 비교적 느린 속도를 낸다.
432 |
433 | 세션은 서버의 자원을 사용하기 때문에 무분별하게 만들다 보면 서버의 메모리가 감당할 수 없어질 수가 있고 속도가 느려질 수 있기 때문에 쿠키를 함께 사용한다.
434 |
435 | #### References
436 |
437 | - [쿠키와 세션 개념 - 라이언 서버](https://interconnection.tistory.com/74)
438 |
439 | ---
440 |
441 | ## #16
442 |
443 | #### DNS가 무엇인가요?
444 |
445 | 모든 네트워크 통신에는 고유의 주소, 즉 IP 주소가 필요하다. 이때 통신을 주고받는 주체가 되는 네트워크에 연결되어 있는 모든 장치들을 host라고 한다. IP는 사람이 이해하고 기억하기 어렵기 때문에 이를 위해서 각 ip에 부여한 이름이 도메인(Domain)이다. 예를 들어 210.89.164.90의 도메인은 naver.com이다.
446 |
447 | DNS(Domain Name Server 또는 Domain Name Service 모두를 의미)는 숫자로 이루어진 IP 주소와 일정한 형식을 가진 도메인을 서로 매핑 시키고 정보를 가지고 있다. 예를 들어 네이버에 접속하기 위해 주소창에 도메인(naver.com)을 입력하면, 컴퓨터는 해당 도메인이 연결된 DNS로 가서 서버 IP를 요청한다.
448 |
449 | 요청받은 네임 서버는 해당 도메인과 연결되어 있는 서버 IP(210.89.164.90)를 찾은 후, 컴퓨터에게 알려준다.
450 |
451 | 이처럼 도메인에 연결된 서버의 주소를 찾아주는 역할이 **DNS**이다.
452 |
453 | > **브라우저가 도메인에 해당하는 IP를 찾는 순서**
454 |
455 | 1. local cache 안에 검색한 해당 도메인의 IP가 있는지 확인한다. 이미 해당 도메인을 방문한 적이 있다면 컴퓨터가 해당 도메인의 IP를 기억하고 있으므로 그것을 사용한다.
456 | 2. 만약 캐시에 없다면 컴퓨터 내부에 파일 형태로 존재하는 hosts 파일을 검색해서 찾는다. 해당 hosts 파일에 특정 도메인과 IP를 매핑 시켜놓으면 해당 도메인은 지정한 IP로 이동한다.
457 | 3. 만약 위의 경우에서 도메인에 대한 IP를 찾지 못하면 최종적으로 DNS를 검색한다.
458 |
459 | 
460 |
461 | #### References
462 |
463 | - [[Network] 네트워크 기초 개념 - 차근차근 개발로그](https://hyuntaekhong.github.io/blog/Network/#3-dnsdomain-name-service)
464 | - [Domain, DNS란 무엇인가 - 매일의 공부 기록](https://study-recording.tistory.com/8)
465 |
466 | ---
467 |
468 | ## #17
469 |
470 | #### REST와 RESTful의 개념을 설명하고 차이를 말해주세요.
471 |
472 | `REST`란 **Re**presentational **S**tate **T**ransfer의 약자로, URI로 자원(Resource)을 명시하고 HTTP 메서드를 통해 해당 자원에 대한 CRUD(Create, Read, Update, Delete) 연산을 적용하는 것을 의미한다.
473 |
474 | 여기서의 자원은 데이터베이스의 정보를 말한다. 하지만 클라이언트가 직접 데이터베이스에 접속해 변경하는 것은 매우 위험한 방식 이다. 그래서 이를 막기 위해 REST API를 사용하는 것이다. **클라이언트**가 서버에 데이터를 조회·생성·삭제·업데이트를 하겠다고 HTTP 메서드로 요청을 하면 **서버**는 로직에 따라 데이터베이스에 접근하여 요청을 처리한다.
475 |
476 | `RESTful`은 REST 아키텍처로 구현된 웹 서비스를 나타내기 위한 용어로, "REST API를 제공하는 웹 서비스는 RESTful하다"처럼 사용된다.
477 |
478 | > **HTTP 메서드 종류**
479 |
480 | 요청의 종류에 다라 다른 HTTP 메서드를 사용하는데 주로 사용하는 대표적인 메서드는 다음과 같다.
481 |
482 | | 메서드 | 역할 |
483 | | :----: | :------------------------------------------------------ |
484 | | GET | 데이터를 조회한다. |
485 | | POST | 데이터를 등록한다. 인증 작업을 거칠 때 사용하기도 한다. |
486 | | DELETE | 데이터를 삭제한다. |
487 | | PUT | 데이터를 새 정보로 통째로 업데이트할 때 사용한다. |
488 | | PATCH | 데이터의 특정 필드를 수정할 때 사용한다. |
489 |
490 | > **URI란?**
491 |
492 | URI는 Uniform Resource Identifier의 약자로, 자원을 식별자로 취급하여 나타내는 주소를 말한다. URI의 종류로 URL과 URN이 있다. URI는 일반적으로 다음과 같은 형식을 갖고 있다.
493 |
494 | 
495 |
496 | #### References
497 |
498 | - [[Network] REST란? REST API란? RESTful이란? - HeeJeong Kwon](https://gmlwjd9405.github.io/2018/09/21/rest-and-restful.html)
499 | - [REST API 제대로 알고 사용하기 - NHN Cloud Meetup!](https://meetup.toast.com/posts/92)
500 | - [URL과 URI의 의미와 차이점 (Difference between URL & URI) - Lael's World](https://blog.lael.be/post/61)
501 | - [통합 자원 식별자 - 위키피디아](https://ko.wikipedia.org/wiki/%ED%86%B5%ED%95%A9_%EC%9E%90%EC%9B%90_%EC%8B%9D%EB%B3%84%EC%9E%90)
502 | - [21장. 백엔드 프로그래밍: Node.js의 Koa 프레임워크 - 리액트를 다루는 기술](http://www.yes24.com/Product/Goods/79260300)
503 |
504 | ---
505 |
506 | ## #18
507 |
508 | #### 소켓(Socket)이 무엇인가요? 자신 있는 언어로 간단히 소켓 생성 예시를 보여주세요.
509 |
510 | `소켓(Socket)`이란 Application 프로세스와 end-to-end 통신을 제공하는 Transport 프로토콜 사이의 인터페이스을 말한다. 즉, Application에서 Transport 프로토콜을 쓰기 위한 API를 말한다.
511 |
512 | 소켓은 크게 UDP와 TCP 두 종류로 분류할 수 있다. 자세한 내용은 [#4. TCP와 UDP의 차이를 설명해주세요.](#4)을 참고!
513 |
514 | 파이썬으로 TCP에서의 소켓과 UDP에서의 소켓 생성 코드를 구현하면 다음과 같다. 소켓을 생성한다고 바로 통신을 할 수 없으며 실제 통신을 하기 위해는 바인딩, 연결 등 추가 작업이 필요하다.
515 |
516 | > **TCP**
517 |
518 | - TCP Client
519 |
520 | ```python
521 | from socket import *
522 |
523 | server_name = "example.com"
524 | server_port = 1234
525 |
526 | client_socket = socket(AF_INET, SOCKET_STREAM) # 소켓 생성
527 | client_socket.connect((server_name, server_port)) # 서버에 연결 요청
528 | ```
529 |
530 | - TCP Server
531 |
532 | ```python
533 | from socket import *
534 |
535 | server_port = 1234
536 |
537 | server_socket = socket(AF_INET, SOCKET_STREAM) # 소켓 생성
538 | server_socket.bind(('', server_port)) # 소켓에 주소 바인딩
539 | server_socket.listen(1) # 클라이언트 연결 대기
540 |
541 | (client_socket, client_address) = server_socket.accept() # 클라이언트 연결 수락
542 | ```
543 |
544 | > **UDP**
545 |
546 | - UDP Client
547 |
548 | ```python
549 | from socket import *
550 |
551 | server_name = "example.com"
552 | server_port = 1234
553 |
554 | client_socket = socket(AF_INET, SOCK_DGRAM) # 소켓 생성
555 | ```
556 |
557 | - UDP Server
558 |
559 | ```python
560 | from socket import *
561 |
562 | server_port = 1234
563 | server_socket = socket(AF_NET, SOCK_DGRAM) # 소켓 생성
564 | server_socket.bind(('', server_port)) # 소켓에 주소 바인딩
565 | ```
566 |
567 | #### References
568 |
569 | - [Chapter 2. Application Layer - Computer Networking: A Top-Down Approach](http://www.yes24.com/Product/Goods/24320296?OzSrank=2)
570 |
571 | ---
572 |
573 | ## #19
574 |
575 | #### Socket.io와 WebSocket의 차이를 설명해주세요.
576 |
577 | > **WebSocket**
578 |
579 | 
580 |
581 | `WebSocket`은 서버와 브라우저 간 연결을 유지한 상태로 데이터를 교환할 수 있도록 하는 **프로토콜**을 말한다.
582 |
583 | 전형적인 브라우저 렌더링 방식은 HTTP 요청에 대한 응답을 받아 브라우저 화면을 깨끗히 지우고 받은 내용을 새로 표시하는 방식인데, 내용을 지우고 다시 그리면 브라우저의 깜박임이 생기게 된다. 이러한 깜박임 없이 필요한 부분만 다시 그리는 상호작용 방식의 수요가 생겼다.
584 |
585 | 이러한 상호작용을 구현하기 위해 Pooling, Long Pooling, Streaming 등 다양한 방식을 사용했지만 요청을 보내고 응답을 보내는 **단방향 메시지 교환 규칙을 준수**하였기 때문에 상호작용하는 웹페이지를 구현하는 것은 매우 어려웠다.
586 |
587 | 이보다 쉽게 구현하기 위해 **브라우저와 서버 간 양방향 메시지 송수신 규칙**이 필요했고 이것이 WebSocket이다.
588 |
589 | > **Socket.io**
590 |
591 | `socket.io`는 서버와 브라우저의 양방향 통신을 가능하게 하는 **모듈**을 말한다. WebSocket의 경우 정말 좋은 기술이지만 오래된 브라우저의 경우 지원을 하지 않는 경우가 있다. 이런 경우 socket.io는 서버와 브라우저의 종류와 버전을 파악하여 가장 적합한 기술을 선택해 양방향 통신이 가능하도록 한다.
592 |
593 | #### References
594 |
595 | - [WebSocket과 Socket.io - NAVER D2](https://d2.naver.com/helloworld/1336)
596 | - [웹소켓 - 위키백과](https://ko.wikipedia.org/wiki/%EC%9B%B9%EC%86%8C%EC%BC%93)
597 | - [웹소켓 - 모던 JavaScript 튜토리얼](https://ko.javascript.info/websocket)
598 | - [websocket, socket.io를 이용한 양방향 통신 - zych1751](http://www.secmem.org/blog/2019/08/17/websocket-socketio/)
599 | - [10.5 Node.js(Express)와 Socket.io - PoiemaWeb](https://poiemaweb.com/nodejs-socketio)
600 |
601 | ---
602 |
603 | ## #20
604 |
605 | #### IPv4와 IPv6 차이를 설명해주세요.
606 |
607 | IPv4와 IPv6는 **인터넷 프로토콜(IP)의 버전**을 말하며, IPv4는 IP의 4번째 버전, IPv6는 IP의 6번째 버전을 말한다. 이 때 인터넷 프로토콜은 호스트 간 패킷 교환 네트워크에서 패킷(Packet) 혹은 데이터그램(Datagram)으로 불리는 정보를 주고받는데 사용하는 프로토콜을 말한다.
608 |
609 | 
610 |
611 | `IPv4`는 헤더에 options이 존재하고, fragmentation/reassembly 기능을 제공해 MTU(Maximum Transport Unit)을 넘는 큰 데이터그램을 쪼개 전송을 하고 도착지에서 재조합을 한다. 또한 checksum 비트도 존재하여 매 라우터마다 checksum 비트를 갱신한다.
612 |
613 | 반면 `IPv6`는 빠른 속도를 위해 fragmentation/reassembly 기능을 제공하지 않으며, 데이터그램의 우선순위를 설정할 수 있는 priority 비트가 존재한다.
614 |
615 | #### References
616 |
617 | - [Chapter 4. Network Layer - Computer Networking: A Top-Down Approach](http://www.yes24.com/Product/Goods/24320296?OzSrank=2)
618 |
619 | ---
620 |
621 | ## #21
622 |
623 | #### MAC Address가 무엇인가요?
624 |
625 | `MAC 주소(Media Access Control Address)`는 Data Link Layer에서 통신을 위해 **네트워크 인터페이스에 할당한 식별자**를 말한다. 즉, 모든 네트워크 장비는 자신의 MAC 주소가 있으며 주소는 장비 제조업체가 할당한다. MAC 주소는 물리적 주소(Physical Address)라고 불리기도 한다.
626 |
627 | > **💡 MAC 주소와 IP 주소의 차이**
628 | > MAC 주소와 IP 주소 모두 통신기기의 식별자라는 것은 동일하다. 다만 MAC 주소는 제조업체가 통신기기에 부여하는 식별자이며 같은 식별자를 같는 통신기기는 없다. IP 주소는 Network Layer에서 통신을 하기 위한 주소로 보통 통신사에서 부여하며 바뀔 수 있다.
629 |
630 | #### References
631 |
632 | - [MAC 주소 - 위키백과](https://ko.wikipedia.org/wiki/MAC_%EC%A3%BC%EC%86%8C)
633 | - [IP Address와 MAC Address 개념 - Crocus](https://www.crocus.co.kr/1515)
634 | - [MAC 주소와 IP 주소의 차이점](https://ko.strephonsays.com/difference-between-mac-address-and-ip-address)
635 | - [아이피 주소와 MAC 주소 (IP Address & MAC Address) - ProHub](https://blog.naver.com/PostView.nhn?isHttpsRedirect=true&blogId=kiminhovator&logNo=220321080118)
636 |
637 | ---
638 |
639 | ## #22
640 |
641 | #### 라우터와 스위치, 허브의 차이를 설명해주세요.
642 |
643 | (여기서의 네트워크는 LAN(Local Area Network)를 말합니다.)
644 |
645 | 
646 |
647 | `라우터(Router)`는 Network Layer 3계층 장비로 **네트워크 사이를 연결하는 장치**이다. 최종 도착지의 네트워크에 도착할 수 있도록 적절한 경로를 설정하여 패킷을 전송한다.
648 |
649 | `스위치(Switch)`는 Data Link Layer 2계층 장비로 **네트워크 내에서 패킷을 전송하는 장치**를 말한다. 스위치로 요청이 들어오면 IP 주소에 대응되는 MAC 주소를 찾아 해당 MAC 주소로 패킷을 전송한다. 만약 IP 주소에 대응되는 MAC 주소가 없다면 허브처럼 브로드캐스트 방식으로 패킷을 전송하고 IP 주소와 MAC 주소를 대응시킨 테이블을 갱신시킨다.
650 |
651 | `허브(Hub)`는 Physical Layer 1계층 장비로 **여러 기기를 연결하여 네트워크를 만들어주는 장치**이다. 패킷을 받으면 연결된 모든 기기에 패킷을 전송한다.
652 |
653 | > **💡 브로드캐스트(Broadcast)란?**
654 | > 브로드캐스트란 LAN에 있는 모든 네트워크 장비들에게 보내는 통신이다.
655 |
656 | #### References
657 |
658 | - [허브, 라우터, 공유기, 스위치의 개념과 차이점 - Easy is Perfect](http://melonicedlatte.com/network/2019/12/21/154500.html)
659 | - [네트워크 스위치와 허브, 라우터는 어떻게 다른 걸까 - IT WORLD](https://www.itworld.co.kr/news/167585)
660 | - [라우터 그리고 스위치 - HelloWorld](https://server-engineer.tistory.com/582)
661 |
662 | ---
663 |
664 | ## #23
665 |
666 | #### SMTP가 무엇인가요?
667 |
668 | `SMTP(Simple Mail Transfer Protocol)`은 **인터넷에서 이메일을 보내기 위해 사용하는 TCP/IP 프로토콜**을 말한다. 사용하는 TCP Port 번호는 25번이다.
669 |
670 | SMTP는 다음의 명령어를 사용하여 메일을 주고 받는다.
671 |
672 | - MAIL 명령: 주소 반환 확립
673 | - RCPT 명령: 메시지 수신자 확립
674 | - DATA 명령: 메시지 텍스트의 첫 신호를 제공
675 |
676 | #### References
677 |
678 | - [간이 우편 전송 프로토콜 - 위키백과](https://ko.wikipedia.org/wiki/%EA%B0%84%EC%9D%B4_%EC%9A%B0%ED%8E%B8_%EC%A0%84%EC%86%A1_%ED%94%84%EB%A1%9C%ED%86%A0%EC%BD%9C)
679 |
680 | ---
681 |
682 | ## #24
683 |
684 | #### 노트북으로 `www.google.com`에 접속을 했습니다. 요청을 보내고 받기까지의 과정을 자세히 설명해주세요.
685 |
686 | 
687 |
688 | > **1단계**
689 |
690 | 웹 사이트에 접속하기 위해서는 **노트북의 IP주소, 1-hop 라우터의 IP 주소, DNS 서버 주소**가 필요하다. 이를 알아 내기 위해 DHCP query가 담긴 IP 데이터그램을 1-hop 라우터에게 전송한다. DHCP 서버가 내장된 라우터가 노트북의 IP주소, 자신의 IP주소, DNS 서버의 IP주소를 담은 DHCP ACK를 다시 노트북에게 전송한다.
691 |
692 | - DNS란 **D**omain **N**ame **S**ystem의 약자로 `www.google.com`과 같은 도메인 주소를 IP 주소로 바꿔주는 시스템을 말한다.
693 | - DHCP 서버는 보통은 라우터에 DHCP 서버가 내장되어 있으며 DHCP 서버에 연결된 클라이언트에게 자동적으로 IP주소를 할당한다. 자세한 내용은 [#28](#28)을 참고!
694 |
695 | > **2단계**
696 |
697 | DNS 서버에 DNS query를 보내기 전에 **1-hop 라우터의 MAC 주소**가 필요하므로 ARP query를 브로드캐스트 방식으로 전송하여 router의 MAC주소를 알아낸다.
698 |
699 | - ARP란 **A**ddress **R**esolution **P**rotocol의 약자로, MAC 주소와 IP 주소를 1:1 매핑하기 위해 사용된다.
700 |
701 | > **3단계**
702 |
703 | `www.google.com`에 요청을 보내기 위해서는 `www.google.com`의 IP주소가 필요하므로, DNS query가 담긴 IP 데이터그램을 DNS 서버에 전송하고 `www.google.com`의 IP 주소를 클라이언트인 노트북에게 전송한다.
704 |
705 | > **4단계**
706 |
707 | TCP 소켓을 생성하고 3-way handshake로 연결을 생성한다. HTTP 요청을 보내고 응답을 받아 브라우저에 렌더링을 하면 Google 웹페이지를 브라우저에서 확인할 수 있다.
708 |
709 | #### References
710 |
711 | - [Chapter 6.7. Life of a web request - Computer Networking: A Top-Down Approach](http://www.yes24.com/Product/Goods/24320296?OzSrank=2)
712 | - [ARP 쉽게 이해하기 - 네트워크 엔지니어 환영의 AWS 기술블로그](https://aws-hyoh.tistory.com/entry/ARP-%EC%89%BD%EA%B2%8C-%EC%9D%B4%ED%95%B4%ED%95%98%EA%B8%B0)
713 |
714 | ---
715 |
716 | ## #25
717 |
718 | #### 여러 네트워크 topology에 대해 간단히 소개해주세요.
719 |
720 | 컴퓨터끼리 정보를 교환하고 교류하는 형태를 의미하는 네트워크에서 토폴로지는 **컴퓨터들의 특정한 망구성 방식**을 의미한다.
721 |
722 | 하나의 네트워크 구성 방식을 보더라도, 노드와 링크와 같은 물리적 배치로 구분하는 **물리적 토폴로지**와 노드 간의 데이터 흐름으로 구분하는 **논리적 토폴로지**로 네트워크 구성을 각각 판단할 수 있다.
723 |
724 | > **Star**
725 |
726 | 중앙에 위치한 메인 노드를 통해 다른 노드와 소통할 수 있는 구조이다.
727 |
728 | - `장점`: 장애 발견이 쉽고 관리가 용이함
729 | - `단점`: 메인 노드에 장애가 발생하면 전체 네트워크 사용 불가능
730 |
731 | 
732 |
733 | > **Bus**
734 |
735 | 버스라는 공통 배선을 통해 노드들이 연결되어 있어서, 한 노드의 신호가 모든 노드에 전달된다. (타겟 노드만 신호에 반응을 하고 다른 노드는 무시한다.)
736 |
737 | - `장점`: 노드 추가 및 삭제가 용이하며, 한 노드에 장애가 발생해도 다른 노드에 영향을 주지 않음
738 | - `단점`: 공통 배선의 크기(대역폭)가 제한되어 있으므로 배선에 과부하가 걸릴 경우 네트워크 성능 저하
739 |
740 | 
741 |
742 | > **Ring**
743 |
744 | 각 노드가 양 옆으로 연결된 원형 구조, 단방향으로 신호가 전달된다.
745 |
746 | - `장점`: 단방향 구조로 단순하고, 중간에 있는 노드들이 증폭기의 역할을 해준다. (거리 제약 적어진다.)
747 | - `단점`: 노드 추가 및 삭제가 어렵다.
748 |
749 | 
750 |
751 | > **Mesh**
752 |
753 | 다수의 노드가 서로 연결된 형태이다. (모두 연결되면 완전 연결형, 일부만 연결되면 부분 연결형)
754 |
755 | - `장점`: 노드의 장애에 영향받지 않으며 유연한 대처가 가능하고 안정적이다.
756 | - `단점`: 구축 비용이 크고, 노드 추가에도 비용이 많이 든다.
757 |
758 | 
759 |
760 | 
761 |
762 | #### References
763 |
764 | - [네트워크 토폴로지 정의 및 종류 - 브릭봇](https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=brickbot&logNo=220418950837)
765 | - [토폴로지 - 풍뎅아 공부하자](https://sungks.tistory.com/268)
766 |
767 | ---
768 |
769 | ## #26
770 |
771 | #### subnet mask에 대해서 설명해주세요.
772 |
773 | > **IP 주소와 서브네팅 (subnetting)**
774 |
775 | IPv4 의 경우 $2^{32}$의 숫자로 주소를 표현하고, 이를 국가, 회사 등 잘게 나눠 어느 영역을 쓰게할 것인지 결정한다.
776 |
777 | 한정된 자원이기 때문에 효율적으로 노드에 주소를 할당하는게 중요하다. 이를 위해 IP 를 쪼개는, 네트워크 파트 + 호스트 파트로 구성하는 서브네팅을 활용한다.
778 |
779 | 기본적으로 IP 주소에 따라 5 개의 클래스로 구분된다. 각 클래스에 따라 네트워크 파트와 호스트 파트가 정해진다.
780 |
781 | 
782 |
783 | 위와 같은 클래스 구조와 더불어 더욱 효율적인 서브네팅을 위해서 사용하는 방법이 서브넷 마스크이다.
784 |
785 | > **서브넷 마스크 (subnet mask)**
786 |
787 | 할당된 IP 주소는 기본적으로 네트워크 파트와 호스트 파트가 정해져있다.
788 |
789 | 효율적인 주소 관리를 위해 내부적으로 호스트 파트를 새로운 네트워크 파트와 호스트 파트로 나눌 수 있다. 이 때 서브넷 마스크를 활용할 수 있다.
790 |
791 | 만약 C 클래스인 192.12.16.1 IP, 255.255.255.0 서브넷 마스크(호스트 파트)가 할당되었을 때 기존의 서브넷 마스크인 마지막 8 비트를 1111 0000 으로 바꾼다면, 4 비트만큼의 네트워크 파트 (그룹), 4 비트만큼의 호스트 (멤버) 를 할당할 수 있다. 이렇게 된다면 동일 네트워크 간에는 커뮤니케이션이 자유롭지만, 다른 네트워크 간에는 라우터를 거쳐야 커뮤니케이션을 할 수 있다.
792 |
793 | 어떤 기업을 생각해보자. 서브넷 마스크로 추가적인 서브네팅을 안한다면 인사팀, 재무팀 등등 여러 팀들이 모두 같은 네트워크 파트를 지니므로 서로에게 접근할 수 있다. 이럴 때 서브넷 마스크를 활용한 서브네팅으로 효율적으로 IP 를 관리할 수 있다.
794 |
795 | #### References
796 |
797 | - [IP 주소 및 서브넷 마스크 - 보안전문가가 되자](https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=hatesunny&logNo=220790654612)
798 | - [[Network] IP주소 클래스(A,B,C class)란? Limky 삽질 블로그](https://limkydev.tistory.com/168?category=954021)
799 | - [서브네팅 목적 및 개념 - 트레비스의 IT 라이프](https://travislife.tistory.com/53)
800 |
801 | ---
802 |
803 | ## #27
804 |
805 | #### data encapsulation이 무엇인가요?
806 |
807 | data encapsulation 은 데이터를 보내는 송신측에서 데이터를 생성하는 방법으로, 네트워크 계층에서 상위 계층에서부터 하위 계층으로 내려올 때마다 각 계층의 헤더를 붙여 보내는 데이터로 만들어낸다.
808 |
809 | 반대로 데이터를 받는 수신측에서는 데이터를 받은 후에 계층을 거슬러 올라가면서 헤더를 떼내며 데이터를 파악한다.
810 |
811 | 
812 |
813 | #### References
814 |
815 | - [[network] 캡슐화 & 역캡슐화 (encalsulation & decapsulation) - CHAEN](https://ychae-leah.tistory.com/20)
816 | - [[네트워크] TCP/ IP 캡슐화 - jhkang-dev](https://jhkang-tech.tistory.com/20)
817 |
818 | ---
819 |
820 | ## #28
821 |
822 | #### DHCP를 설명해주세요.
823 |
824 | DHCP (Dynamic Host Configuration Protocol) 는 동적으로 IP 주소나 기타 정보들을 관리해주는 프로토콜을 말한다. 관리해야하는 컴퓨터가 많고 이들의 IP 를 모두 직접 할당하고 관리하려면 상당히 복잡하고 시간이 많이들지만, DHCP 를 사용하면 이러한 문제점을 해결할 수 있다.
825 |
826 | DHCP 는 UDP 를 사용하여 클라이언트/서버 구조로 통신한다.
827 | 그 과정은 아래와 같다.
828 |
829 | 1. `DHCP discover`: 컴퓨터가 동일 서브넷으로 브로드캐스팅(255.255.255.255)으로 DHCP 서버를 찾는다.
830 | 2. `DHCP offer`: DHCP 가 사용가능한 IP 주소의 리스트를 컴퓨터에게 전달한다.
831 | 3. `DHCP request`: 컴퓨터가 리스트 중 하나의 IP 주소를 선택하여 서버에 전달한다.
832 | 4. `DHCP ack`: DHCP 가 컴퓨터에게 해당 IP 주소를 허락/거절하는 메세지를 전달한다.
833 |
834 | > **장점**
835 |
836 | - DHCP 서버에서 자동으로 IP 를 관리해주므로 편리하다. IP 에 변동이 있을 때, DHCP 에만 정보를 입력하면 된다.
837 | - 사용중인 컴퓨터에 대해서만 할당하므로 효율적이다.
838 |
839 | > **단점**
840 |
841 | - DHCP 서버에 의존하기 때문에 서버가 다운되는 경우 모든 컴퓨터에서 인터넷을 할 수 없다.
842 | - 초기 DHCP 세팅 시간 및 트래픽이 크다.
843 | - 단말 컴퓨터를 끌 경우, 완전히 주소가 release 될 때 까지 해당 IP 를 사용할 수 없다.
844 |
845 | #### References
846 |
847 | - [DHCP 열심히 정리한 글 :) - Don't forget your time](https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=hai0416&logNo=221578608161)
848 | - [DHCP란 그 개념부터 알아보자 - 네트워크보안 ](https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=haionvpn&logNo=40181076143)
849 |
850 | ---
851 |
852 | ## #29
853 |
854 | #### routing protocol을 몇 가지 설명해주세요. (ex. link state, distance vector)
855 |
856 | 
857 |
858 | 패킷을 전달할 때 어느 경로로 갈지 정하는 것을 라우팅이라고 한다.
859 |
860 | > **라우팅 경로 고정 여부**
861 |
862 | 어떤 경로로 라우팅할지를 미리 정해두냐 동적으로 정하냐에 따라 `정적 라우팅`, `동적 라우팅` 으로 구분한다.
863 |
864 | > **내/외부 라우팅**
865 |
866 | 동적 라우팅에서 AS (Auotonomous System, 하나의 네트워크 관리자에 의해 관리되는 네트워크 집단) 를 기준으로 내부적으로 동작하냐, 외부적으로 동작하냐에 따라 `내부 라우팅` (RIP, IGRP, OSPF, EIGRP) 과 `외부 라우팅` (BGP, EGP) 으로 나눈다.
867 |
868 | > **라우팅 테이블 관리**
869 |
870 | 동적 라우팅에서 어떤 방식으로 라우팅 테이블을 관리하느냐에 따라서도 방법이 다르다.
871 | 크게 link state, distance vector 방법이 있다.
872 |
873 | `distance vector` 방법은 현재 위치 (단말 또는 라우터) 까지의 방향과 거리를 기록한 라우팅 테이블을 인접한 라우터들에게 전달하고 갱신한다.
874 | 메모리가 적게 들고 구성이 쉽지만, 전체 테이블 구성 시간이 길어질 수 있고 같은 경로를 반복해서 도는 루핑 문제가 발생할 수 있다. (EIGRP 는 루핑이 발생하지 않음)
875 | distance vector 를 사용하는 프로토콜로는 RIP, EIGRP, BGP 등이 있으며, distance vector 는 `벨만-포드 알고리즘` 에 기반한다.
876 |
877 | `link state` 방법은 인접 테이블에 정보를 전달했으면 또 그 인접 테이블들은 이 정보를 바로 인접 테이블로 넘겨, 직접 연결되지 않은 모든 라우터들도 현재 정보를 파악할 수 있다.
878 | 정확하고 루핑 문제가 없다는 장점이 있어 대형 네트워크에서 많이 사용되지만 메모리의 소모와 cpu 로드가 많다는 단점이 있다.
879 | link state 를 사용하는 프로토콜로는 OSPF, IS-IS 등이 있으며, link state 는 `다익스트라 알고리즘`에 기반한다.
880 |
881 | #### References
882 |
883 | - [라우팅 프로토콜(Routing Protocol) - 자비스가 필요해](https://needjarvis.tistory.com/159)
884 | - [라우팅 프로토콜 종류 - 개발일기](https://developmentdiary.tistory.com/494)
885 | - [라우팅 프로토콜의 종류 - 청년 고득녕](https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=nackji80&logNo=221431942767)
886 | - [디스턴스 벡터/링크 스테이트 - 이삭이의 토스트 공장](https://toastfactory.tistory.com/286)
887 |
888 | ---
889 |
890 | ## #30
891 |
892 | #### 이더넷(ethernet)이 무엇인가요?
893 |
894 | 이더넷은 근거리 유선 통신을 위해 사용되는 네트워킹 방법으로 [CSMA/CD](https://security-nanglam.tistory.com/193)프로토콜을 사용한다. IEEE 802.3 에 표준으로 정의되었다.
895 |
896 | > **장점**
897 |
898 | - 적은 용량의 데이터를 보낼 때 성능이 좋다.
899 | - 비용이 적고 관리가 쉽다.
900 | - 구조가 단순하다.
901 |
902 | > **단점**
903 |
904 | - 캐리어 충돌이 발생할 수 있다.
905 | - 충돌이 발생하면 지연이 생긴다.
906 |
907 | CSMA/CD 방법을 간략히 말하자면 버스 구조로 통신을 하는데 캐리어라는 네트워킹 상의 신호를 감지하여 캐리어가 없으면 정보를 보내는 방식이다.
908 |
909 | #### References
910 |
911 | - [[네트워크] 이더넷(Ethernet) - DevOwen](https://devowen.com/351)
912 | - [[네트워크] 이더넷? \_ Ethernet에 대하여 - 낭람](https://security-nanglam.tistory.com/192)
913 |
914 | ---
915 |
916 | ## #31
917 |
918 | #### client와 server의 차이점을 설명해주세요.
919 |
920 | 네트워크 상에서 요청을 보내는 대상을 `client`, 요청에 응답하는 대상을 `server` 라고 한다. client 와 server 는 고정되지 않고 요청에 따라 바뀐다. 전에는 요청을 보내는 client 였어도 다음 번에는 다른 노드로부터 요청을 받으면 server 가 된다.
921 |
922 | #### References
923 |
924 | - [서버 클라이언트 뜻 - 오나바딩요](https://blog.naver.com/myca11/221369799273)
925 |
926 | ---
927 |
928 | ## #32
929 |
930 | #### delay, timing(jitter), throughput 차이를 설명해주세요.
931 |
932 | 위 세가지 개념은 모두 네트워크의 성능과 관련되어 있다.
933 |
934 | > **delay**
935 |
936 | 하나의 데이터 패킷이 출발 지점에서 도착 지점에 도착한 시간을 의미한다.
937 |
938 | 딜레이는
939 |
940 | - `Processing Delay (처리 지연)`: 라우터가 들어온 패킷의 헤더를 확인하고 처리하는데 걸리는 시간
941 | - `Queueing Delay (큐 지연)`: 라우터가 다른 패킷을 처리하느라 패킷이 라우터의 큐에서 대기하는 시간
942 | - `Transmission Delay (전송 지연)`: 라우터의 성능 (전송 속도) 에 따라 패킷이 논리회로를 통과할 때까지 걸리는 시간
943 | - `Propagation Delay (전파 지연)`: 라우터간 거리에 의해 발생하는 지연 시간
944 |
945 | 의 합으로 계산된다.
946 |
947 | 
948 |
949 | > **timing(jitter)**
950 |
951 | delay 의 변동을 (변화량 수준) 의미한다. 같은 스위치가 아닌 경우 패킷마다 대기 시간이 달라지므로 지터가 생긴다.
952 |
953 | > **throughput**
954 |
955 | 지정된 시간동안 실제로 전송된 정보량을 의미한다.
956 |
957 | 데이터가 지나갈 수 있는 통로의 크기인 bandwidth 와 헷갈릴 수 있는데, bandwidth 가 크더라도 실제로 전송된 정보량이 적으면 throughput 이 적은 것이다.
958 |
959 | #### References
960 |
961 | - [Network의 4가지 종류 - 공대생의 개발 노트](https://corona-world.tistory.com/47)
962 | - [4. 네트워크의 delay, loss, throughput - 나도 잘 모름](https://snnchallenge.tistory.com/98)
963 | - [[네트워크]latency, bandwidth와 throughput 개념 정리 - 코딩 세상](https://darkstart.tistory.com/141)
964 | - [Latency Delay Jitter 의 명쾌한 비교](https://sensechef.com/1156)
965 |
--------------------------------------------------------------------------------
/answers/6-operating-system.md:
--------------------------------------------------------------------------------
1 | > **📌 질문은 [WeareSoft님의 tech-interview](https://github.com/WeareSoft/tech-interview)를 참고하였습니다.**
2 |
3 | ## Table of Contents
4 |
5 | - [프로세스와 스레드의 차이(Process vs Thread)를 알려주세요.](#1)
6 | - [멀티 프로세스 대신 멀티 스레드를 사용하는 이유를 설명해주세요.](#2)
7 | - [캐시의 지역성에 대해 설명해주세요.](#3)
8 | - [Thread-safe에 대해 설명해주세요. (hint: critical section)](#4)
9 | - [뮤텍스와 세마포어의 차이를 설명해주세요.](#5)
10 | - [스케줄러가 무엇이고, 단기/중기/장기로 나누는 기준에 대해 설명해주세요.](#6)
11 | - [CPU 스케줄러인 FCFS, SJF, SRTF, RR, Priority Scheduling에 대해 간략히 설명해주세요.](#7)
12 | - [동기와 비동기의 차이를 설명해주세요.](#8)
13 | - [메모리 관리 전략에는 무엇이 있는지 간략히 설명해주세요.](#9)
14 | - [가상 메모리에 대해 설명해주세요.](#10)
15 | - [교착상태(데드락, Deadlock)의 개념과 조건을 설명해주세요.](#11)
16 | - [사용자 수준 스레드와 커널 수준 스레드의 차이를 설명해주세요.](#12)
17 | - [외부 단편화와 내부 단편화에 대해 설명해주세요.](#13)
18 | - [Context Switching이 무엇인지 설명하고 과정을 나열해주세요.](#14)
19 | - [Swapping에 대해 설명해주세요.](#15)
20 |
21 | ---
22 |
23 | ## #1
24 |
25 | #### 프로세스와 스레드의 차이(Process vs Thread)를 알려주세요.
26 |
27 | 프로그램(Program)이란 파일이 저장 장치에 저장되어 있지만 메모리에 올라가 있지 않은 정적인 상태를 말한다.
28 |
29 | 프로세스(Process)란 운영체제로부터 시스템 자원을 할당받는 작업의 단위로 메모리에 올라와 실행되고 있는 프로그램의 인스턴스(독립적인 개체)를 의미한다.
30 |
31 | > **할당받는 시스템 자원의 예**
32 |
33 | - CPU 시간
34 | - 운영되기 위해 필요한 주소 공간
35 | - Code, Data, Stack, Heap의 구조로 되어 있는 독립된 메모리 영역
36 |
37 | > **프로세스의 특징**
38 |
39 | - 프로세스는 각각 독립된 메모리 영역(Code, Data, Stack, Heap의 구조)을 할당받는다.
40 | - 프로세스당 최소 1개의 스레드(메인 스레드)를 가지고 있다.
41 | - 각 프로세스는 별도의 주소 공간에서 실행되며, 한 프로세스는 다른 프로세스의 변수나 자료구조에 접근할 수 없다.
42 | - 한 프로세스가 다른 프로세스의 자원에 접근하려면 프로세스 간의 통신(IPC, Inter-Process Communication)을 사용해야 한다.
43 |
44 | 
45 |
46 | 스레드(Thread)란 프로세스가 할당받은 자원을 이용하는 실행의 단위로 프로세스와는 다른 더 작은 실행 단위 개념이다. 스레드는 프로세스의 코드에 정의된 절차에 따라 실행되는 특정한 수행 경로이다.
47 |
48 | > **스레드의 특징**
49 |
50 | - 스레드는 프로세스 내에서 각각 Stack 영역만 따로 할당받고 Code, Data, Heap 영역은 공유한다.
51 | - 스레드는 한 프로세스 내에서 동작되는 여러 실행의 흐름으로, 프로세스 내의 주소 공간이나 자원들(힙 공간 등)을 같은 프로세스 내에 스레드끼리 공유하면서 실행된다.
52 | - 같은 프로세스 안에 있는 여러 스레드들은 같은 힙 공간을 공유한다. 반면에 프로세스는 다른 프로세스의 메모리에 직접 접근할 수 없다.
53 | - 각각의 스레드는 별도의 레지스터와 스택을 갖고 있지만, 힙 메모리는 서로 읽고 쓸 수 있다.
54 | - 한 스레드가 프로세스 자원을 변경하면, 다른 이웃 스레드(sibling thread)도 그 변경 결과를 즉시 볼 수 있다.
55 |
56 | 
57 |
58 | #### References
59 |
60 | - [[OS] 프로세스와 스레드의 차이 - Heee's Development Blog](https://gmlwjd9405.github.io/2018/09/14/process-vs-thread.html)
61 | - [프로세스와 스레드의 차이 - 개발장](https://velog.io/@raejoonee/%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4%EC%99%80-%EC%8A%A4%EB%A0%88%EB%93%9C%EC%9D%98-%EC%B0%A8%EC%9D%B4)
62 |
63 | ---
64 |
65 | ## #2
66 |
67 | #### 멀티 프로세스 대신 멀티 스레드를 사용하는 이유를 설명해주세요.
68 |
69 | **멀티 프로세스**란 하나의 응용프로그램을 여러 개의 프로세스로 구성하여 각 프로세스가 하나의 작업을 처리하도록 하는 것이다.
70 |
71 | - `장점`: 여러 개의 자식 프로세스 중 하나에 문제가 발생하면 그 자식 프로세스만 죽는 것 이상으로 다른 영향이 확산되지 않는다.
72 | - `단점`
73 | - Context Switching 과정에서 캐시 메모리 초기화 등 무거운 작업이 진행되고 많은 시간이 소모되는 등의 오버헤드가 발생하게 된다.
74 | - 프로세스는 각각의 독립된 메모리 영역을 할당받았기 때문에 하나의 프로그램에 속하는 프로세스들 사이의 변수를 공유할 수 없다.
75 |
76 | **멀티 스레드**란 하나의 응용프로그램을 여러 개의 스레드로 구성하고 각 스레드로 하여금 하나의 작업을 처리하도록 하는 것이다. 윈도우, 리눅스 등 많은 운영체제들이 멀티 프로세싱을 지원하고 있지만 멀티 스레드를 기본으로 하고 있다. 웹 서버는 대표적인 멀티 스레드 응용 프로그램이다.
77 |
78 | - `장점`
79 | - 프로세스를 생성하여 자원을 할당하는 시스템 콜이 줄어들어 자원을 효율적으로 관리할 수 있다.
80 | - 스레드 간 데이터를 주고받는 것이 간단해지고 시스템 자원 소모가 줄어들게 된다.
81 | - 스레드 사이의 작업량이 작아 Context Switching이 빠르다.
82 | - 스레드는 프로세스 내의 Stack 영역을 제외한 모든 메모리를 공유하기 때문에 통신의 부담이 적다.
83 | - `단점`
84 | - 주의 깊은 설계가 필요하며, 디버깅이 까다롭다.
85 | - 단일 프로세스 시스템의 경우 효과를 기대하기 어렵다.
86 | - 프로세스 밖에서 스레드 각각을 제어할 수 없다.
87 | - 멀티 스레드의 경우 자원 공유의 문제가 발생한다.(동기화 문제)
88 | - 하나의 스레드에 문제가 발생하면 전체 프로세스가 영향을 받는다.
89 |
90 | > **멀티 프로세스 대신 멀티 스레드를 사용하는 이유**
91 |
92 | - **자원의 효율성 증대**
93 |
94 | 프로세스 간의 Context Switching 시 단순히 CPU 레지스터 교체뿐만 아니라 RAM과 CPU 사이의 캐시 메모리에 대한 데이터까지 초기화되므로 오버헤드가 발생한다. 멀티 프로세스로 실행되는 작업을 멀티 스레드로 실행할 경우, **프로세스를 생성하여 자원을 할당하는 시스템 콜이 줄어들어** 자원을 효율적으로 관리할 수 있다.
95 |
96 | 스레드는 프로세스 내의 메모리를 공유하기 때문에 독립적인 프로세스와 달리 스레드 간 데이터를 주고받는 것이 간단해지고 시스템 자원 소모가 줄어들게 된다.
97 |
98 | - **처리 비용 감소 및 응답 시간 단축**
99 |
100 | 스레드는 Stack 영역을 제외한 모든 메모리를 공유하기 때문에 프로세스 간의 통신(IPC)보다 스레드 간의 통신의 비용이 적으므로 작업들 간의 통신의 부담이 줄어든다.
101 |
102 | Context Switching 시 스레드는 Stack 영역만 처리하기 때문에 프로세스 간의 전환 속도보다 스레드 간의 전환 속도가 빠르다.
103 |
104 | > **Context Switching**
105 |
106 | CPU에서 여러 프로세스를 돌아가면서 작업을 처리하는 데 이 과정을 Context Switching라 한다. 동작 중인 프로세스가 대기를 하면서 해당 프로세스의 상태(Context)를 보관하고, 대기하고 있던 다음 순서의 프로세스가 동작하면서 이전에 보관했던 프로세스의 상태를 복구하는 작업을 말한다.
107 |
108 | > 동기화 문제(Synchronization Issue)
109 |
110 | 멀티 스레드를 사용하면 각각의 스레드 중 어떤 것이 어떤 순서로 실행될지 그 순서를 알 수 없다. 만약 A 스레드가 어떤 자원을 사용하다가 B 스레드로 제어권이 넘어간 후 B 스레드가 해당 자원을 수정했을 때, 다시 제어권을 받은 A 스레드가 해당 자원에 접근하지 못하거나 바뀐 자원에 접근하게 되는 오류가 발생할 수 있다.
111 |
112 | 이처럼 여러 스레드가 함께 전역 변수를 사용할 경우 발생할 수 있는 충돌을 동기화 문제라고 한다.
113 |
114 | Context Switching에 대한 자세한 내용은 [#14. Context Switching이 무엇인지 설명하고 과정을 나열해주세요.](#14) 참고!
115 |
116 | #### References
117 |
118 | - [[OS] 프로세스와 스레드의 차이 - Heee's Development Blog](https://gmlwjd9405.github.io/2018/09/14/process-vs-thread.html)
119 | - [프로세스와 스레드의 차이 - 개발장](https://velog.io/@raejoonee/%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4%EC%99%80-%EC%8A%A4%EB%A0%88%EB%93%9C%EC%9D%98-%EC%B0%A8%EC%9D%B4)
120 |
121 | ---
122 |
123 | ## #3
124 |
125 | #### 캐시의 지역성에 대해 설명해주세요.
126 |
127 | **캐시 메모리**는 CPU의 처리 속도와 메모리의 속도 차이로 인한 병목현상을 완화하기 위해 사용하는 고속 버퍼 메모리이다. 주기억장치에 있는 데이터를 액세스하려면 비교적 오랜 시간이 걸리게 되는데 이를 줄이기 위해 데이터를 빠르게 액세스할 수 있도록 중간에 캐시 메모리를 두는 것이다. 주기억장치 내에서 자주 읽고 쓰는 데이터의 일부를 캐시 메모리에 불러와 속도 차이를 줄이고, 주기억장치와 CPU 간 신호 교환에 이용되는 Memory Bandwidth를 I/O 사용에 집중할 수 있게 만든다.
128 |
129 | 캐시 메모리는 `적중률(Hit rate)`을 극대화하기 위해 데이터 `지역성(Locality)의 원리`를 사용한다. 지역성의 전제조건으로는 프로그램은 모든 코드나 데이터를 균등하게 액세스하지 않는다는 특성을 기본으로 한다. 즉, `지역성(Locality)`이란 기억 장치 내의 정보를 균일하게 액세스하는 것이 아닌 어느 한순간에 특정 부분을 집중적으로 참조하는 특성이다.
130 |
131 | **데이터 지역성**은 대표적으로 `시간적 지역성(Temporal Locality)`, `공간적 지역성(Spatial Locality)`, `순차적 지역성(Sequential Locality)`으로 나뉜다.
132 |
133 | 시간적 지역성(temporal locality): CPU가 한 번 참조한 데이터는 다시 참조할 가능성이 높다.
134 |
135 | 공간적 지역성(spatial locality): CPU가 참조한 데이터와 인접한 데이터 역시 참조될 가능성이 높다.
136 |
137 | 순차적 지역성(sequential locality): 분기가 발생하지 않는 한 명령어는 메모리에 저장된 순서대로 인출/실행된다.
138 |
139 | 지역성은 어디까지나 경향에 대한 것이므로 항상 캐시의 높은 적중률을 보장해 주지는 않는다.
140 |
141 | > 적중률(Hit rate)
142 |
143 | 캐시 메모리가 있는 컴퓨터 시스템은 CPU가 메모리에 접근하기 전 먼저 캐시 메모리에서 원하는 데이터의 존재 여부를 확인한다. 이때 필요한 데이터가 있는 경우를 적중(hit), 없는 경우를 실패(miss)라고 한다.
144 |
145 | **요청한 데이터를 캐시 메모리에서 찾을 확률**을 적중률(hit rate)이라고 한다.
146 |
147 | 캐시 메모리의 성능은 적중률에 의해 결정된다.
148 |
149 | 
150 |
151 | #### References
152 |
153 | - [[OS] 캐시(Cache) ? - 어제보다 한 걸음 더](https://k39335.tistory.com/38)
154 | - [캐시(Cache) 메모리와 지역성::하드웨어 - 제이붐](https://junboom.tistory.com/34)
155 | - [캐시 - 위키백과](https://ko.wikipedia.org/wiki/%EC%BA%90%EC%8B%9C)
156 | - [캐시 메모리(cache memory)의 개요 정리 - 코알라알락's BLOG](https://zion830.tistory.com/46)
157 |
158 | ---
159 |
160 | ## #4
161 |
162 | #### Thread-safe에 대해 설명해주세요. (hint: critical section)
163 |
164 | `스레드 안전(Thread-safe)`이란 멀티 스레드 프로그래밍에서 일반적으로 어떤 함수나 변수, 객체를 여러 스레드가 동시에 접근해도 프로그램 실행에 문제가 없음을 뜻한다. 즉, 멀티 스레드 환경에서 여러 쓰레드가 동시에 동일한 코드를 실행시켰을 때 올바른 결과를 얻는 것을 말한다.
165 |
166 | ```python
167 | import threading
168 | from threading import Thread
169 |
170 | def increase_count():
171 | global count
172 | for _ in range(1000000):
173 | count += 1
174 |
175 |
176 | if __name__=="__main__":
177 | count = 0
178 |
179 | # 스레드 생성
180 | thread_a = Thread(target=increase_count, name="thread a")
181 | thread_b = Thread(target=increase_count, name="thread b")
182 |
183 | # 스레드 실행
184 | thread_a.start()
185 | thread_b.start()
186 |
187 | # 스레드 종료
188 | thread_a.join()
189 | thread_b.join()
190 |
191 | print("최종 count:", count)
192 | ```
193 |
194 | 다음은 스레드 안전하지 않은 경우의 코드이다. 사용자가 원하는 결과는 스레드가 함수를 실행한 수에 1000000을 곱한 값이 count의 값이 되는 것이다. 하지만 다음 코드를 실행하면, count는 2000000가 아닌 1448523이 나온다. (실행할 때마다 값이 달라진다)
195 |
196 | 왜 그럴까? 바로 두 스레드가 count 변수를 공유하고 있기 때문이다. 이 때 공유 자원에 접근하는 코드 영역을 `임계 영역(critical section)`이라고 하며, 둘 이상의 프로세스가 동시에 임계 영역에 접근하는 것을 막는 것을 `상호 배제(mutual exclusion)`라고 한다.
197 |
198 | 파이썬에서는 threading 모듈에 있는 Lock 객체로 상호 배제를 시킬 수 있다. 다음 코드를 실행하면 최종 count는 우리가 원했던 2000000이 나온다.
199 |
200 | ```python
201 | import threading
202 | from threading import Thread
203 |
204 | def increase_count():
205 | lock.acquire()
206 | global count
207 | for _ in range(1000000):
208 | count += 1
209 | lock.release()
210 |
211 |
212 | if __name__=="__main__":
213 | count = 0
214 |
215 | # 스레드 락 생성
216 | lock = threading.Lock()
217 |
218 | # 스레드 생성
219 | thread_a = Thread(target=increase_count, name="thread a")
220 | thread_b = Thread(target=increase_count, name="thread b")
221 |
222 | # 스레드 실행
223 | thread_a.start()
224 | thread_b.start()
225 |
226 | # 스레드 종료
227 | thread_a.join()
228 | thread_b.join()
229 |
230 | print("최종 count:", count)
231 | ```
232 |
233 | #### References
234 |
235 | - [스레드 안전 - 위키백과](https://ko.wikipedia.org/wiki/%EC%8A%A4%EB%A0%88%EB%93%9C_%EC%95%88%EC%A0%84)
236 | - [[OS] Lecture 6. Process Synchronization and Mutual Exclusion (1/7) - Introduction / 운영체제 강의 - HPC Lab. KOREATECH](https://www.youtube.com/watch?v=wdaf2gy83uU&list=PLBrGAFAIyf5rby7QylRc6JxU5lzQ9c4tN&index=12&ab_channel=HPCLab.KOREATECHHPCLab.KOREATECH)
237 |
238 | ---
239 |
240 | ## #5
241 |
242 | #### 뮤텍스와 세마포어의 차이를 설명해주세요.
243 |
244 | `상호배제(Mutual Exclusion, Mutex)`는 **한 스레드/프로세스가 임계 영역에 있으면 다른 스레드/프로세스가 못 들어오도록 막는 것**을 말한다. 상호배제는 다음과 같이 수행된다.
245 |
246 | 1. 임계 영역 진입 전 다른 스레드/프로세스가 임계 영역에 안에 있는지 검사한다.
247 | 2. 없다면 임계 영역에 진입하여 공유 자원에 접근한다. 있다면 기다린다.
248 | 3. 끝나면 임계 영역을 벗어나 다른 프로세스에게 임계 영역에 벗어났음을 알린다.
249 |
250 | `세마포어(Semaphore)`는 현재 **공유 자원에 접근할 수 있는 스레드/프로세스의 수를 나타내는 값을 두어 상호배제를 하는 방법**을 말한다. 세마포어는 변수로 음이 아닌 정수 S(여러 개가 존재 가능)와, 함수로 초기화 연산, P(검사), V(증가) 연산이 있으며, 다음과 같이 수행된다.
251 |
252 | 1. 변수 S를 초기화 연산을 통해 초기화 시킨다.
253 | 2. P 함수를 실행하여 S가 0보다 큰지 검사한다.
254 | 3. 만약 0보다 크다면, S를 1 감소시키고 임계 영역에 진입하여 공유 자원에 접근한다.
255 | 4. 크지 않다면, 스레드/프로세스를 Ready Queue에 넣어 대기시킨다.
256 | 5. 임계 영역에서 나온 스레드/프로세스는 V 함수를 실행하여 Ready Queue에 스레드/프로세스가 있는지 체크한다. 만약 있다면, 그 중 1개를 임계 영역에 진입시킨다. 없다면, S를 1 증가시킨다.
257 |
258 | #### References
259 |
260 | - [뮤텍스(Mutex)와 세마포어(Semaphore)의 차이 - Worth spreading](https://worthpreading.tistory.com/90)
261 | - [[OS] Lecture 6. Process Synchronization and Mutual Exclusion (1/7) - Introduction / 운영체제 강의 - HPC Lab. KOREATECH](https://www.youtube.com/watch?v=wdaf2gy83uU&list=PLBrGAFAIyf5rby7QylRc6JxU5lzQ9c4tN&index=12&ab_channel=HPCLab.KOREATECHHPCLab.KOREATECH)
262 | - [[OS] Lec 6. Process Synchronization and Mutual Exclusion (5/7) - Semaphore (OS supported Sol. 2) - HPC Lab. KOREATECH](https://www.youtube.com/watch?v=CitsUz-Dx7A&list=PLBrGAFAIyf5rby7QylRc6JxU5lzQ9c4tN&index=16&ab_channel=HPCLab.KOREATECHHPCLab.KOREATECH)
263 |
264 | ---
265 |
266 | ## #6
267 |
268 | #### 스케줄러가 무엇이고, 단기/중기/장기로 나누는 기준에 대해 설명해주세요.
269 |
270 | 시스템 내에는 여러 개의 프로세스가 존재한다. 이 때 시간(time)과 공간(space) 즉, 자원을 할당할 프로세스를 선택해야 하는데, 이 역할을 맡은 것을 `스케줄러`라고 한다.
271 |
272 | 스케줄러의 목적은 **시스템 성능 향상**이며 대표적인 시스템 성능 지표로 응답시간(response time), 작업 처리량(throughput), 자원 활용도(resource utilization)이 있다. **목적에 따라 다양한 성능 지표를 고려**하여 스케줄러를 선택한다.
273 |
274 | 스케줄러는 발생하는 빈도와 할당하는 자원에 따라 **장기/중기/단기 스케줄러**로 나눌 수 있다.
275 |
276 | `장기 스케줄러(Long-term Scheduler)`는 시스템에 제출할 작업을 결정하는 Job Scheduling(Job → created)에서 사용하며, 시스템 내에 프로세스 수를 조절한다. 이 때 중요한 것은 CPU든 I/O든 모두 써서 효율성을 높이기 위해서 I/O bounded와 compute-bounded 프로세스들을 잘 섞어서 선택해야 한다.
277 |
278 | `중기 스케줄러(Mid-term Scheduler)`는 메모리 할당을 결정하는 Memory Allocation(suspended ready → ready)에서 사용한다.
279 |
280 | `단기 스케줄러(Short-term Scheduler)`는 프로세서를 할당 받을 프로세스를 결정하는 Process Scheduling(ready → running)에서 사용하며, 가장 빈번하게 발생하므로 매우 빨라야 한다.
281 |
282 | > **응답시간 vs 작업 처리량 vs 자원 활용도**
283 |
284 | - `응답시간(response time)`: 작업 요청으로부터 응답을 받을 때까지의 시간
285 | - `작업 처리량(throughput)`: 단위 시간 동안 완료된 작업의 수
286 | - `자원 활용도(resource time)`: 주어진 시간동안 자원이 활용된 시간
287 |
288 | > **I/O Bounded 프로세스 vs Compute-bounded 프로세스**
289 |
290 | - `I/O Bounded 프로세스`: I/O 대기시간이 긴 프로세스
291 | - `Compute-bounded 프로세스`: CPU 사용시간이 긴 프로세스
292 |
293 | > **스케줄링의 단계**
294 |
295 | 
296 |
297 | #### References
298 |
299 | - [[OS] Lecture 5. Process Scheduling (1/4) / 운영체제 강의 - HPC Lab. KOREATECH](https://www.youtube.com/watch?v=_gNeoGQx-Tc&list=PLBrGAFAIyf5rby7QylRc6JxU5lzQ9c4tN&index=8&ab_channel=HPCLab.KOREATECHHPCLab.KOREATECH)
300 |
301 | ---
302 |
303 | ## #7
304 |
305 | #### CPU 스케줄러인 FCFS, SJF, SRTF, RR, Priority Scheduling에 대해 간략히 설명해주세요.
306 |
307 | > **스케줄링 정책**
308 |
309 | 스케줄링 정책(scheduling policy)에 따라 스케줄러를 **선점/비선점**과 **정적/동적 우선순위**로 나눌 수 있다.
310 |
311 | - `비선점 스케줄링(Non-preemptive scheduling)`: 할당 받을 자원을 스스로 반납할 때까지 사용한다. 이는 Context Switching 부하가 적다는 장점이 있지만, 우선순위가 높은 프로세스가 들어올 경우 우선순위가 역전되어 우선순위가 낮은 프로세스의 처리 시간이 늘어나 평균 응답시간이 증가한다는 단점이 있다.
312 |
313 | - `선점 스케쥴링(Preemptive Scheduling)`: 타의에 의해 자원을 빼앗길 수 있다. 비선점 스케줄링과 다르게 Context Switching 부하가 크지만, 응답성이 높으므로 real-time system, time-sharing system에 적합하다.
314 |
315 | - `정적 우선순위(Static Priority)`: 프로세스 생성 시 결정된 우선순위가 유지된다. 이는 구현을 쉽게 하고, Context Switching이 덜 일어나기 때문에 부하가 적다. 하지만 시스템 환경 변화에 대한 대응이 어렵다.
316 |
317 | - `동적 우선순위(Dynamic Priority)`: 프로세스의 상태 변화에 따라 우선순위를 변경한다. 구현이 복잡하지만 시스템 환경 변화에 유연하게 대응이 가능하다.
318 |
319 | > **대표적인 스케줄러**
320 |
321 | `FCFS(First Come First Service)`는 비선점 스케줄러로, **Ready Queue에 먼저 도착한 프로세스를 먼저 처리**한다. 자원을 효율적으로 사용할 수 있어 일괄 처리 시스템에 적합하다. 하지만 만약 수행시간이 긴 프로세스가 먼저 도착하면 다른 프로세스의 대기시간이 길어지는 Convoy Effect로 인해 평균 응답시간이 길다는 단점이 있다.
322 |
323 | `RR(Round Robin)`은 선점 스케줄러로, Ready Queue에 먼저 도착한 프로세스를 처리한다는 점에서 FCFS와 같지만 **자원 사용 시간(time quantum)이 있다는 점**에서 차이가 있다. 프로세스가 할당된 시간이 지나면 자원을 반납하게 하여 특정 프로세스의 자원 독점을 방지한다.
324 |
325 | `SJF(Shortest Job First)`는 비선점 스케줄러로, **CPU burst time이 가장 작은 프로세스를 먼저 처리**한다. 가장 실행시간이 적은 프로세스를 먼저 처리하기 때문에 대기 시간을 줄일 수 있지만, 실행시간을 예측한다는 점에서 비현실적이며 계속해서 짧은 프로세스만 처리하므로 긴 프로세스는 뒤로 밀린다는 단점이 있다.
326 |
327 | `SRTF(Shortest Remaining Time First)`는 선점 스케줄러로, **잔여 실행 시간이 더 적은 프로세스를 먼저 처리**한다. SJF의 장점을 극대화 했으나, 프로세스 생성 시 총 실행 시간 예측이 필요하고 잔여 시간을 계속 추적해야 해서 overhead가 크고 구현 및 사용이 비현실적이다.
328 |
329 | `Priority Scheduling`은 각 프로세스에 지정된 우선순위를 기준으로 **높은 우선순위를 가진 프로세스를 먼저 처리**한다. 이 방식의 단점은 계속해서 우선순위가 높은 프로세스가 들어오면 그 프로세스를 먼저 처리하므로 낮은 프로세스는 뒤로 밀리는 starvation 문제가 발생한다. 이는 일정 시간 이상 기다리면 프로세스의 우선순위를 높여주는 aging 방식으로 해결할 수 있다.
330 |
331 | #### References
332 |
333 | - [[OS] Lecture 5. Process Scheduling (2/4) - FCFS, RR / 운영체제 강의 - HPC Lab. KOREATECH](https://www.youtube.com/watch?v=r1JVA7yOPAM&list=PLBrGAFAIyf5rby7QylRc6JxU5lzQ9c4tN&index=9&ab_channel=HPCLab.KOREATECHHPCLab.KOREATECH)
334 | - [[OS] Lecture 5. Process Scheduling (3/4) - SPN, SRTN, HRRN / 운영체제 강의 - HPC Lab. KOREATECH](https://www.youtube.com/watch?v=keY9Wi7scEs&list=PLBrGAFAIyf5rby7QylRc6JxU5lzQ9c4tN&index=10&ab_channel=HPCLab.KOREATECHHPCLab.KOREATECH)
335 | - [CPU Scheduling, Process 이해하기 - 어쩐지 오늘은](https://zzsza.github.io/development/2018/07/29/cpu-scheduling-and-process/)
336 |
337 | ---
338 |
339 | ## #8
340 |
341 | #### 동기와 비동기의 차이를 설명해주세요.
342 |
343 | **동기**는 요청에 대한 결과를 받은 후에야 다음 요청을 진행하는 방식으로 결과를 받을 때까지 대기해야한다. 동기는 직관적인 구조이지만 비효율적이다.
344 |
345 | **비동기**는 요청 결과에 관계 없이 바로 다음 요청을 수행하고, 결과는 `콜백` 함수를 통해 받는다. 비동기는 설계가 복잡하지만 효율적이다.
346 |
347 | 
348 |
349 | > **Blocking, Non-Blocking**
350 |
351 | Blocking 과 Non-Blocking은 결과에 대한 관점보다는 `System Call(직접 제어할 수 없는 대상의 처리)` 의 관점으로 이해할 수 있다. Blocking은 System Call 이 완료될 때까지 Waiting Queue에서 대기한다. Non-Blocking은 System Call이 완료와 상관없이 자신의 작업을 진행한다.
352 |
353 | #### References
354 |
355 | - [동기(Synchronous) 작업과 비동기(Asynchronous) 작업, 그리고 블락(Blocking) 과 넌블락(Non-Blocking) 의 개념 - Jins' Dev Inside](https://jins-dev.tistory.com/entry/%EB%8F%99%EA%B8%B0Synchronous-%EC%9E%91%EC%97%85%EA%B3%BC-%EB%B9%84%EB%8F%99%EA%B8%B0Asynchronous-%EC%9E%91%EC%97%85-%EA%B7%B8%EB%A6%AC%EA%B3%A0-%EB%B8%94%EB%9D%BDBlocking-%EA%B3%BC-%EB%84%8C%EB%B8%94%EB%9D%BDNonBlocking-%EC%9D%98-%EA%B0%9C%EB%85%90)
356 | - [Synchronous(동기) Vs Asynchronous(비동기) - Nesoy Blog](https://nesoy.github.io/articles/2017-01/Synchronized)
357 | - [[용어정리] 동기방식&비동기방식 비교 - 고구마](https://jieun0113.tistory.com/73)
358 | - [동기방식, 비동기방식 - fromzoo](https://velog.io/@codemcd/Sync-VS-Async-Blocking-VS-Non-Blocking-sak6d01fhx)
359 |
360 | ---
361 |
362 | ## #9
363 |
364 | #### 메모리 관리 전략에는 무엇이 있는지 간략히 설명해주세요.
365 |
366 | 제한된 메모리 크기를 효율적으로 사용하기 위해 메모리 관리 전략이 필요하다.
367 |
368 | > **스왑**
369 |
370 | 프로세스가 실행되기 위해서는 메모리에 올라가야한다. 실행되어야 하는 여러 프로세스 중, 기존에 메모리에 올라간 프로세스를 보조 기억장치 (HDD, SSD) 로 보내는 것을 swap-out, 보조 기억장치에 있던 프로세스를 메모리에 올리는 것을 swap-in 이라고 한다. 어떤 프로세스를 swap-out 시킬지에 대한 대표적인 방법으로는 round-robin 이 있다.
371 |
372 | 더 자세한 설명은 [15. Swapping에 대해 설명해주세요](#15)을 참고!
373 |
374 | > **압축**
375 |
376 | 메모리에 프로세스들을 올리다보면 아래 사진과 같이 빈 공간(free) 이 생긴다. 이 공간을 fragmentation(단편화) 이라고 한다. 현재 메모리에서 프로세스와 단편화를 파악하고 프로세스가 연속적으로 메모리 주소에 할당되게 단편화를 없애는 방법을 압축이라 한다. 압축은 효율적이지 못하기 때문에 좋은 메모리 관리 방법이 아니다.
377 |
378 | 
379 |
380 | > **페이징**
381 |
382 | 메모리에 연속적으로 프로세스를 할당하지 않고, 메모리를 페이지라는 단위로 물리적으로 나눠서 페이지에 프로세스를 올리는 방법이다. 프로세스가 페이지 크기보다 크다면 여러 페이지를 사용한다.
383 | 페이지 크기보다 작은 프로세스가 할당되면 내부적으로 공간이 남는 내부 단편화가 발생할 수 있다.
384 |
385 | > **세그멘테이션**
386 |
387 | 페이징은 물리적 단위로 메모리를 나눴다면, 세그멘테이션은 논리적 단위로 메모리를 나눈다. 이를 위해 세그멘테이션 테이블을 사용하고, 테이블에는 시작주소인 base 와 최대 크기인 limit 가 포함되어 있다.
388 | 세그멘테이션은 세그멘트 간에 할당되지 않은 공간이 남는 외부 단편화가 발생할 수 있다.
389 |
390 | 
391 |
392 | #### References
393 |
394 | - [[CS 기초 - 운영체제] 메모리 관리 전략 - deannn.log](https://velog.io/@deannn/CS-%EA%B8%B0%EC%B4%88-%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EA%B4%80%EB%A6%AC-%EC%A0%84%EB%9E%B5)
395 | - [스와핑이란? - 양햄찌가 만드는 세상](https://jhnyang.tistory.com/103)
396 | - [[운영체제(OS)] 14. 세그멘테이션 - 끄적끄적](https://velog.io/@codemcd/%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9COS-14.-%EC%84%B8%EA%B7%B8%EB%A9%98%ED%85%8C%EC%9D%B4%EC%85%98)
397 |
398 | ---
399 |
400 | ## #10
401 |
402 | #### 가상 메모리에 대해 설명해주세요.
403 |
404 | 메모리의 크기보다 큰 프로세스는 어떻게 해야 실행이될까? 이 문제를 해결하기 위한 방법으로, 프로세스에서 필요한 부분만 메모리에 올려 실행이 가능하게 동작하는 방법을 가상 메모리라고 한다. 페이지와 세그멘테이션 중 주로 페이지를 이용하는 **Demand Paging** 방법을 사용한다.
405 |
406 | **Demand Paging** 는 프로세스에서 현재 필요한 페이지만 메모리에 올리는 방법이다. 이를 위한 페이지 테이블은 기존의 테이블에서 valid 와 modified 가 추가적으로 필요하다.
407 |
408 | 
409 |
410 | valid 는 해당 페이지가 메모리에서 사용되고 있는지를 나타낸다. 페이지가 메모리에 없는 경우 (valid == 0) 를 **page fault** 라고 한다. 아래의 과정으로 페이지를 메모리에 할당한다.
411 |
412 | 1. 해당 페이지 valid bit 확인
413 | 2. valid 가 0 이면 CPU 인터럽트, 해당 ISR 로 이동
414 | 3. ISR 에서 backing store 를 탐색하여 해당 프로세스의 페이지 찾음
415 | 4. 해당 페이지를 빈 프레임에 할당
416 | 5. 페이지 테이블 갱신 (valid 1 로 변경)
417 | 6. 다시 프로세스 실행
418 |
419 | 여러 프로세스의 필요한 페이지를 메모리에 올리는 것은 효율적이다. 하지만 결국 한정된 자원을 쓰다보면 메모리가 꽉차는 시점이 생긴다. 이 때 어떤 페이지를 내릴지 **Page Replacement** 를 판단해야 한다.
420 |
421 | 메모리에 올라갔던 페이지가 다시 내려가면 victim page 라고 하는데, modified bit 를 확인하여 페이지가 수정되지 않은 (modified == 0) 페이지 중 랜덤하게 혹은 가장 먼저 올라온 페이지를 내릴 수 있다.
422 |
423 | #### References
424 |
425 | - [가상 메모리 - Hashtag](https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=yeop9657&logNo=220729107141)
426 | - [[운영체제(OS)] 15. 가상메모리 - 끄적끄적 ](https://velog.io/@codemcd/%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9COS-15.-%EA%B0%80%EC%83%81%EB%A9%94%EB%AA%A8%EB%A6%AC)
427 |
428 | ---
429 |
430 | ## #11
431 |
432 | #### 교착상태(데드락, Deadlock)의 개념과 조건을 설명해주세요.
433 |
434 | 교착상태란, 두 개 이상의 작업이 서로 상대방의 작업이 끝나기 만을 기다리고 있기 때문에 결과적으로 아무것도 완료되지 못하는 상태를 가리킨다. 교착상태의 조건은 아래와 같다.
435 |
436 | - **상호배제**(Mutual exclusion) : 프로세스들이 필요로 하는 자원에 대해 배타적인 통제권을 요구한다.
437 | - **점유대기**(Hold and wait) : 프로세스가 할당된 자원을 가진 상태에서 다른 자원을 기다린다.
438 | - **비선점**(No preemption) : 프로세스가 어떤 자원의 사용을 끝낼 때까지 그 자원을 뺏을 수 없다.
439 | - **순환대기**(Circular wait) : 각 프로세스는 순환적으로 다음 프로세스가 요구하는 자원을 가지고 있다.
440 |
441 | 현재 대부분의 운영체제들은 교착상태를 막는 것이 불가능하여, 운영체제마다 각기 다른 방법으로 교착상태에 대응한다. 주요 접근 방식은 `예방`, `회피`, `무시`, `발견`, `회복` 등이 있다. 이 중에서 예방은 위의 `교착상태의 조건` 중 하나를 제거하는 방식으로 진행되며, 회피는 부가적인 교착상태 회피 알고리즘을 사용한다. 또한 회복을 위해서는 "교착상태에 있는 프로세스들을 하나씩 종료해가는 방법"과 "사용되는 자원이 적은 프로세스 등을 위주로 자원을 선점할 수 있도록 하는 방법"이 쓰인다.
442 |
443 | > **[Dining Philosophers](https://m.blog.naver.com/hirit808/221788147057)** 문제를 떠올리면, 쉽게 이해할 수 있다.
444 |
445 | #### References
446 |
447 | - [교착 상태 - 위키백과](https://ko.wikipedia.org/wiki/%EA%B5%90%EC%B0%A9_%EC%83%81%ED%83%9C)
448 | - [[OS] 교착상태란 무엇인가? - 코딩팩토리](https://coding-factory.tistory.com/311)
449 | - [KOCW 운영체제 8: 식사하는 철학자 문제, 해결 코드(Dining Philosopher Problem) - 큐의 Qriosity Log](https://m.blog.naver.com/hirit808/221788147057)
450 |
451 | ---
452 |
453 | ## #12
454 |
455 | #### 사용자 수준 스레드와 커널 수준 스레드의 차이를 설명해주세요.
456 |
457 | **사용자 수준 스레드**란, 유저 레벨에서 생성되고 동작하는 스레드이다. 커널이 제공하는 pthread와 같은 **스레드 라이브러리**를 사용하여 스레드를 만들고, 사용자 단에서 스레드를 관리한다는 특징을 가진다.
458 |
459 | 사용자 수준 스레드는 스케줄링 결정이나 동기화를 위해 커널을 호출하지 않고 사용자 수준의 스레드 스케줄러를 이용한다. 따라서 (사용자/커널)모드 전환과 Context Switch가 없어, 인터럽트 발생 시에도 오버헤드가 적다. 그러나 사용자 수준 스레드는 시스템 전반에 걸친 스케줄링 우선순위를 지원하지 않기 때문에, 무슨 스레드가 먼저 동작할 지 모른다는 단점과 프로세스에 속한 스레드 중 I/O 작업등에 의해 하나라도 블락(block)이 걸린다면 전체 스레드가 블락된다는 단점도 존재한다.
460 |
461 | **커널 수준 스레드**란, 커널 레벨에서 생성되는 스레드로, 커널이 직접 관리한다는 특징이 있다. 하나의 프로세스는 적어도 하나의 커널 스레드를 가지게 되며, 프로그래머 요청에 따라 스레드를 생성하더라도, **스케줄링하는 주체가 커널**이면 커널 레벨(Kernel Level) 스레드라고 한다.
462 |
463 | 커널 수준 스레드는 다음과 같은 장점을 가지고 있다. 프로세스의 스레드들을 몇몇 프로세서에 한꺼번에 디스패치(dispatch) 할 수 있기 때문에 멀티프로세서 환경에서 매우 빠르게 동작한다. 또한 다른 스레드가 입출력 작업이 다 끝날 때까지 다른 스레드를 사용해 다른 작업을 진행할 수 있다. 커널이 각 스레드를 개별적으로 관리할 수 있으며, 커널이 직접 스레드를 제공해 주기 때문에 안정성과 다양한 기능이 제공된다.
464 |
465 | 반면에 스케줄링과 동기화를 위해 커널을 호출하는데 무겁고 오래걸린다는 단점이 있다. 또한, 커널 수준 스레드는 스케줄링 과정에서, 저장한 내용을 다시 불러오는 과정이 필요하다. 이는, 사용자 모드에서 커널 모드로의 전환이 빈번하게 이뤄져 성능 저하를 유발한다. 또한 사용자가 프로그래밍할 때 구현하기 어렵고 자원을 더 많이 소비하는 경향이 있다는 단점이 있다.
466 |
467 | > **멀티 스레드 모델**
468 |
469 | 
470 |
471 | 사용자 수준 스레드와 커널 수준 스레드에 얘기하기 전에, 멀티 스레드 모델을 먼저 이해하는 것이 좋다. 멀티 스레드 모형이 위와 같이 존재하고, 어떤 멀티 스레드 모델을 사용하느냐에 따라서, 다르게 동작하기 때문에 사용자/커널 수준 스레드 차이가 발생하는 것이다. 추가적으로, 다대다 모델과 일대일 모델과 다대일 모델을 모두 채택하여 사용하는 경우가 있는데, 이를 `혼합형 모델`이라고 한다.
472 |
473 | > **사용자/커널 수준 스레드 구조 차이**
474 |
475 | 
476 |
477 | > **스레드를 생성하는 방법**
478 |
479 | - **kernel의 지원없이 완전히 user space에서만 library를 제공하는 방법**: 라이브러리의 함수를 호출하는 것은 시스템 호출이 아니라 사용자 공간의 지역함수를 호출한다.
480 | - **운영체제에 의해 kernel space에서 구현하는 방법**: 라이브러리 API를 호출하는 것은 kernel system call을 사용한다.
481 |
482 | #### References
483 |
484 | - [커널 레벨 스레드 vs 사용자 레벨 스레드 - Crocus](https://www.crocus.co.kr/1255)
485 | - [운영체제 - 쓰레드란?(Thread,사용자 수준 쓰레드, 커널 수준 쓰레드, 혼합형 쓰레드) -코딩스타트](https://coding-start.tistory.com/199)
486 | - [스레드 모델, 사용 - ckstn0777](https://velog.io/@ckstn0777/OS-%EC%8A%A4%EB%A0%88%EB%93%9C-%EB%AA%A8%EB%8D%B8-%EC%82%AC%EC%9A%A9)
487 |
488 | ---
489 |
490 | ## #13
491 |
492 | #### 외부 단편화와 내부 단편화에 대해 설명해주세요.
493 |
494 | **메모리 단편화(Memory Fragmentation)** 는 RAM에서 메모리의 공간이 작은 조각으로 나뉘어져 사용가능한 메모리가 존재하지만, 할당이 불가능한 상태를 말한다. 자세히 설명하자면, 어떤 태스크가 메모리를 할당받기 위해서는, 연속된 메모리 공간이 필요하다. 그러나 메모리 단편화가 일어나면, 할당되지 않은 메모리의 총량이 충분해도, 이들이 작은 메모리 파편(Memory Fragment)으로 존재하고 있기 때문에 메모리 할당이 불가능한 상황이 발생한다.
495 |
496 | 
497 |
498 | **내부 단편화(Internal Fragmentation)** 란, 메모리를 할당할 때 프로세스가 필요한 양보다 더 큰 메모리가 할당되어서 프로세스에서 사용하는 메모리 공간이 낭비 되는 상황을 말한다. 예를 들어, 메모장을 켰는데 OS가 4kb를 할당해주었다고 해보자. 그런데 실제로는 1kb만큼만 사용했다고 한다면, 필요 이상으로 프로세스가 메모리를 할당받았으므로 내부 단편화가 3kb만큼 생겼다고 할 수 있다.
499 |
500 | **외부 단편화(External Fragmentation)** 란, 작은 메모리가 중간중간에 존재해서 메모리 공간은 충분하지만 실제로 할당할 수 없는 상황을 말한다. 메모리가 할당되고 해제되는 작업이 반복될 때 작은 메모리가 중간에 생기게 된다. 이를 hole이라고 부른다. 이렇게 중간에 끼인 hole들이 많아지면, 메모리 낭비로 인해, 총 가용공간이 충분하더라도 새로운 태스크가 메모리를 할당받지 못하는 상황이 올 수 있다.
501 | 예를 들어, 위의 그림처럼 메모리의 할당과 해제의 반복으로 인해 메모리 중간에 빈 hole들이 만들어졌다고 해보자. 현재 모든 hole의 총합은 16MB 이고, 9MB짜리 프로세스를 할당하고자 한다. 빈 메모리의 공간중에 제일 큰 빈 메모리(hole)의 크기가 9MB 보다 작을 때, 외부 단편화가 일어났다고 할 수 있다.
502 |
503 | > **메모리 할당 방법**
504 |
505 | 메모리 할당 방법은 크게 연속할당 방식과 불연속 할당 방식으로 나뉠 수 있다. **연속할당 방식**에는 `고정분할 방식`, `가변분할 방식`이 있고, **불연속 할당 방식**에는 `페이징 기법`과 `세그멘테이션 기법`, `페이지드 세그멘테이션`(Paged Segmentations) 기법 등이 있다.
506 |
507 | - **압축(Compaction)기법**
508 |
509 | 주기적으로 삭제 공간을 회수하여, 메모리 공간을 정리하는 방식이다. 그러나 비용이 많이 든다는 단점이 있다.
510 |
511 | - **페이징(Paging)기법**: 가상메모리사용, 외부 단편화 해결, 내부 단편화 존재
512 |
513 | 
514 |
515 | 쉽게말해, 프로세스를 일정한 단위로 잘라서 사용하자는 방식이다. 프로세스의 주소 공간을 동일한 크기의 페이지 단위로 나누어 물리적 메모리의 서로 다른 위치에 페이지들을 저장하는 방식을 말한다. 이때, 논리(가상) 메모리의 단위는 페이지(page), 물리 메모리의 단위는 프레임(frame)이라고 부른다.
516 |
517 | 페이징 기법을 사용하면 연속적이지 않은 공간도 활용할 수 있기 때문에 외부 단편화 문제를 해결할 수 있다. 대신 페이지 단위에 알맞게 꽉채워 쓰는게 아니므로 내부 단편화 문제는 여전히 존재한다. 페이지 단위를 작게하면 내부 단편화 문제도 해결할 수 있겠지만 대신 page mapping 과정이 많아지므로 오히려 효율이 떨어질 수 있다.
518 |
519 | - **세그멘테이션(Segmentation)기법**: 가상메모리사용, 내부 단편화 해결, 외부 단편화 존재
520 |
521 | 
522 |
523 | 하나의 프로세스를 구성하는 주소 공간은 일반적으로 코드, 데이터, 스택 등의 의미 있는 단위들로 구성되며, 이렇게 기능적인 구조를 하나의 세그먼트 단위로 삼아, 분할하여 저장된다. 즉, 페이징기법에서 가상메모리를 같은 크기의 단위로 분할했지만 세그멘테이션 기법에서는 가상메모리를 서로 크기가 다른 논리적 단위인 세그먼트로 분할해서 메모리를 할당하여 실제 메모리 주소로 변환을 하게 된다. 각 세그먼트는 연속적인 공간에 저장되어 있다. 세그먼트들의 크기가 다르기 때문에 미리 분할해 둘 수 없고 메모리에 적재될 때 빈 공간을 찾아 할당해야한다. 마찬가지로 mapping을 위해 세그먼트 테이블이 필요하다.
524 |
525 | 프로세스가 필요한 메모리 만큼 할당해주기 때문에 내부단편화는 일어나지 않으나 여전히 중간에 프로세스가 메모리를 해제하면 생기는 hole, 즉 외부 단편화 문제는 여전히 존재한다.
526 |
527 | #### References
528 |
529 | - [메모리 단편화(Memory Fragmentation)가 무엇이고 왜 발생하는가? - 기본기를 쌓는 정아마추어 코딩블로그](https://jeong-pro.tistory.com/91)
530 | - [os/CH.07 메모리 관리 - cs-special-forces-headquarters](https://github.com/LandvibeDev/cs-special-forces-headquarters/blob/main/os/CH.07%20%EB%A9%94%EB%AA%A8%EB%A6%AC%20%EA%B4%80%EB%A6%AC/CH07%20%EB%A9%94%EB%AA%A8%EB%A6%AC%20%EA%B4%80%EB%A6%AC%201b36c524aebc4550908d46538a87c73e.md)
531 | - [메모리 단편화(Memory Fragmentation)가 무엇이고 왜 발생하는가? - 기본기를 쌓는 정아마추어 코딩블로그](https://jeong-pro.tistory.com/91)
532 |
533 | ---
534 |
535 | ## #14
536 |
537 | #### Context Switching이 무엇인지 설명하고 과정을 나열해주세요.
538 |
539 | Context Switching이란, 현재 실행중인 프로세스의 정보를 저장하고 다른 프로세스를 실행시킬 때 발생한다. CPU는 하나의 프로세스 정보만 기억할 수 있기 때문에, 다른 프로세스를 실행하기 위해서는, 기존에 실행중이던 프로세스의 상태 또는 레지스터 값(Context)을 PCB에 저장해야 한다. 기존의 값을 저장한 후, 다음 실행시킬 프로세스의 상태와 레지스터값을 PCB에서 읽어와서 레지스터에 적재하는 작업을 Context Switching 이라 한다.
540 |
541 | Context Switching 과정은 다음과 같다.
542 |
543 | 
544 |
545 | 1. Interrupt나 시스템 호출에 의해 context switching 요구
546 | 2. User Mode에서 Kernel Mode로 변경
547 | 3. 기존 프로세스의 현재 context를 PCB에 저장
548 | 4. 다음에 실행할 프로세스의 상태정보를 PCB에서 복구한 후 다음 프로세스를 실행
549 | 5. Kernel Mode에서 User Mode로 변경
550 |
551 | > **Context Switching이 발생하는 상황**
552 |
553 | Context Switching은 인터럽트 발생 시에 발생하고, 인터럽트는 실행 중인 CPU 사용 할당 시간을 모두 소모하거나, 입출력을 위해 대기하는 경우에 발생하며, 프로세스의 CPU 제어권이 다른 프로세스에게 이양되는 상황으로 볼 수 있다. 따라서, 프로세스 상태와도 관련이 있으며, 3가지 상태 변화에 따라 인터럽트가 발생한다. Context Switch를 하는 주체는 OS 스케줄러이다.
554 |
555 | 1. `running` → `ready`
556 | 2. `ready` → `running`
557 | 3. `running` → `waiting`
558 |
559 | > **PCB(Process Control Block)**
560 |
561 | 프로세스를 관리하는데 있어 필요한 정보(메타 데이터)를 담고있는 운영체제 커널의 자료구조이다. 프로세스가 생성될 때마다 고유의 PCB가 생성되며, 프로세스가 완료되면 PCB는 제거된다. PCB에는 `Process ID`, `Process State`(ex. ready, running), `Program Counter`(다음 instruction), `Register 값`, `Pointer`, `CPU scheduling/Memory/Process information` 등의 정보가 포함된다.
562 |
563 | > **Thread 단위의 Context Switching**
564 |
565 | Process는 Thread보다 Context Switching 오버헤드가 크다. Thread는 Stack 영역을 제외한 모든 메모리를 공유하기 때문이다.
566 |
567 | #### References
568 |
569 | - [os/CH.05 프로세스 관리 - cs-special-forces-headquarters](https://github.com/LandvibeDev/cs-special-forces-headquarters/blob/main/os/CH.05%20%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4%20%EA%B4%80%EB%A6%AC/CH.05%20%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4%20%EA%B4%80%EB%A6%AC.md)
570 | - [OS - Context Switch(컨텍스트 스위치)가 무엇인가? - 기본기를 쌓는 정아마추어 코딩블로그](https://jeong-pro.tistory.com/93)
571 | - [[Context Switching] 프로세스와 쓰레드에서의 컨텍스트 스위칭 - 은비로운 개발일기](https://agh2o.tistory.com/12)
572 | - [Context Switching - 지식덤프](http://jidum.com/jidums/view.do?jidumId=442)
573 | - [[OS] PCB와 Context Switching - require('develop')](https://m.blog.naver.com/adamdoha/222019884898)
574 |
575 | ---
576 |
577 | ## #15
578 |
579 | #### Swapping에 대해 설명해주세요.
580 |
581 | 스와핑(Swapping)이란, **주기억장치(메인메모리)에 적재한 하나의 프로세스와 보조기억장치(하드디스크)에 적재한 다른 프로세스의 메모리를 교체하는 기법**이다.
582 |
583 | 프로세스가 실행되기 위해서는, 프로세스의 명령어와 명령어가 접근하는 데이터가 메모리에 적재되어있어야 한다. 메모리가 부족하면, 메모리 내에 존재하던 기존 프로세스를 backing store(하드디스크, 보조기억장치)라는 공간으로 내릴 수 있다.(=쫒아낸다) 그리고 다시 필요할 때 메모리에 불러와서 사용할 수도 있다. 필요없는 데이터를 backing store에 저장하는 것을 swap out, 필요한 데이터를 메모리에 올리는 것을 swap in이라고 한다. (메모리 기준으로 in, out) **프로세스 단위로 swap in, swap out하는 것**을 swapping이라고 한다.
584 |
585 | > **표준 스와핑과 페이지 단위 스와핑**
586 |
587 | 
588 |
589 | 스와핑을 사용하면, 실제 물리 메모리보다 더 많은 프로세스를 수용할 수 있다. 스와핑의 가장 중요한 역할은 프로세스의 수를 조절하여, 다중 프로그래밍의 정도(degree of muliprogramming)를 조절 할 수 있다는 것이다. 유휴 상태가 오래 지속되는 프로세스가 스와핑에 적합하며, swap out 될 대상 프로세스는 스와퍼(swapper)라고 불리는 **중기 스케쥴러**(medium-term scheduler)에 의해 선정된다. 주의할 점은, 스와핑이라는 개념이 프로세스가 종료되어 그 주소 공간을 디스크로 내쫓는 것이 아니라, 특정한 이유로 수행 중인 프로세스의 주소 공간을 일시적으로 메모리에서 디스크로 내려놓는 것을 의미한다는 것이다.
590 |
591 | 그러나 위와 같이 프로세스 단위로 스와핑하는 표준 스와핑 방법은 최근에 많이 사용되지 않는다. 메모리와 저장장치 사이에 프로세스 전체를 이동시키는 것이 힘들기 때문이다. 대신, 페이지 단위 스와핑을 이용한다.
592 |
593 | > **Backing Store**
594 |
595 | 스왑 영역(swap area)라고도 부르며, 디스크 내에 파일 시스템과는 별도로 존재하는 일정 영역을 말한다. 프로세스가 수행중인 동안에만 디스크에 일시적으로 저장하는 공간이므로 저장 기간이 상대적으로 짧은 저장공간이다. 다수의 사용자 프로세스를 담을 수 있을 만큼 충분히 큰 저장공간이어야 하고 어느 정도의 접근 속도가 보장되어야 한다는 특징이 있다.
596 |
597 | #### References
598 |
599 | - [[운영체제]Swapping 스와핑(swap 스왑)이란? - 양햄찌가 만드는 세상](https://jhnyang.tistory.com/103)
600 | - [운영체제에서 스와핑(swapping) - 노는 게 제일 좋아](https://luv-n-interest.tistory.com/478)
601 | - [os/CH.07 메모리 관리 - cs-special-forces-headquarters](https://github.com/LandvibeDev/cs-special-forces-headquarters/blob/main/os/CH.07%20%EB%A9%94%EB%AA%A8%EB%A6%AC%20%EA%B4%80%EB%A6%AC/CH07%20%EB%A9%94%EB%AA%A8%EB%A6%AC%20%EA%B4%80%EB%A6%AC%201b36c524aebc4550908d46538a87c73e.md)
602 |
--------------------------------------------------------------------------------
/answers/7-data-structure.md:
--------------------------------------------------------------------------------
1 | > **📌 질문은 [WeareSoft님의 tech-interview](https://github.com/WeareSoft/tech-interview)를 참고하였으며, 질문에 대한 답변은 직접 작성하였습니다.**
2 |
3 | ## Table of Contents
4 |
5 | - [linked list](#1)
6 | - [single linked list](#1-1)
7 | - [double linked list](#1-2)
8 | - [circular linked list](#1-3)
9 | - [hash table](#2)
10 | - [stack](#3)
11 | - [queue](#4)
12 | - [circular queue](#4-1)
13 | - [graph](#5)
14 | - [tree](#6)
15 | - [binary tree](#6-1)
16 | - [full binary tree](#6-2)
17 | - [complete binary tree](#6-3)
18 | - [bst(binary search tree)](#6-4)
19 | - [heap(binary heap)](#7)
20 | - [min heap](#7-1)
21 | - [max heap](#7-2)
22 | - [Red-black Tree](#8)
23 | - [B-Tree](#9)
24 |
25 | ---
26 |
27 | ## #1
28 |
29 | #### linked list
30 |
31 | linked list는 서로 떨어져 있는 데이터를 메모리 주소를 참조함으로써 이어진 것처럼 사용할 수 있다. linked list는 구조체가 이어진 형태로 존재하며, 이 구조체를 `노드`라고 부른다. 노드는 값을 담고 있는 `데이터 필드`와 다음 구조체를 가리키는 `링크 필드(포인터)`로 구성된다. 정확히는, 포인터가 다음 구조체의 주소를 담고 있다. 보통, linked list의 맨 첫 원소를 가리키는 head 포인터와 맨 마지막 원소를 가리키는 tail 포인터를 통해, 리스트의 요소에 접근하거나 수정한다. linked list는 구현 방법에 따라, single linked list와 double linked list, circular linked list 등으로 구분할 수 있다.
32 |
33 | > **Array vs. Linked list**
34 |
35 | array에서 중간에 값을 삽입하고 싶다면, 삽입할 위치 뒤의 모든 데이터가 한 칸씩 이동해야 한다는 단점이 있다. 또한, array가 할당받은 공간이 부족한데, 메모리상 뒤쪽의 메모리가 비어있지 않으면, 모든 데이터가 더 큰 홀로 이사를 가야 한다는 단점도 존재한다. linked list는 연속된 공간을 사용하지 않아도 되기 때문에 앞서 언급했던 array의 단점을 모두 해소할 수 있다. 그러나 N번째 데이터를 참조하고 싶을 때, 계속해서 다음 주소를 참조하는 형식으로 따라가야 하므로 메모리 참조에 시간이 오래 걸린다. 따라서 삽입과 삭제가 빈번한 경우에는 linked list를 사용하고, 참조가 빈번하게 일어날 때는 array를 쓰는 것이 바람직하다.
36 |
37 | > **Time Complexity 비교**
38 |
39 | | 구분 | Array | Linked List |
40 | | :------: | :------: | :---------: |
41 | | `insert` | $O(n)$ | $O(1)$ |
42 | | `delete` | $O(n)$ | $O(1)$ |
43 | | `find` | $O(1)$ | $O(n)$ |
44 |
45 | > **삽입, 삭제, 접근 방법**
46 |
47 | - 접근: 원하는 원소가 나올때까지 링크 필드(포인터, 다음 노드)를 계속해서 탐색한다.
48 | - 삽입: 삽입할 노드의 next에 현재 위치의 next를 연결한 후, 현재 위치의 next에 삽입할 노드의 주소를 넣어준다.
49 | - 삭제: 삭제할 노드의 next를 앞선 노드의 next에 연결해준다.
50 |
51 | > **기본적인 linked list 구조 (=Single linked list 구조)**
52 |
53 | 
54 |
55 | ---
56 |
57 | ## #1-1
58 |
59 | #### single linked list
60 |
61 | 
62 |
63 | [#1 Linked list](#1)에서 언급한 내용은 모두 Single linked list에 해당한다. Single linked list는 linked list 중에서도 가장 기본적인 구조로 되어 있으며, head에서 tail까지 단방향으로 포인터가 이어져 있으므로 N 번째 노드에서 N-1 번째 노드에 접근할 수 없다. 대신, 다시 head로부터 N-1 번의 탐색을 통해 접근해야 한다.
64 |
65 | #### References
66 |
67 | - [연결 리스트의 개념과 종류 - suitepotato](https://velog.io/@suitepotato/00007)
68 |
69 | ---
70 |
71 | ## #1-2
72 |
73 | #### double linked list
74 |
75 | 
76 |
77 | [#1-1 Single linked list](#1-1)은 단방향 연결이기 때문에 한번 다음 노드로 이동하면, 이전 노드로 돌아가기 힘들다는 단점이 있었다. 그러나 Double linked list는 뒤의 노드의 주소뿐만 아니라, 이전 노드의 주소도 담고 있다. 하나의 노드는 하나의 데이터와 두 개의 링크를 가지고 있으며, 각각의 링크를 prev와 next라고 부른다. 다음 노드를 참조하고 싶다면 next 링크가 담고 있는 주소를 확인하면 되고, 이전의 노드를 참조하고 싶다면 prev 링크가 가지는 주소를 확인하면 된다.
78 |
79 | #### References
80 |
81 | - [연결 리스트의 개념과 종류 - suitepotato](https://velog.io/@suitepotato/00007)
82 |
83 | ---
84 |
85 | ## #1-3
86 |
87 | #### circular linked list
88 |
89 | 
90 |
91 | 앞서 언급했던 linked list 유형들과는 다르게, tail이 다시 head를 가리키는 구조를 가지고 있다. 따라서, tail 노드의 next에는 NULL이 들어가는 것 대신, head의 주소가 들어간다.
92 |
93 | #### References
94 |
95 | - [연결 리스트의 개념과 종류 - suitepotato](https://velog.io/@suitepotato/00007)
96 |
97 | ---
98 |
99 | ## #2
100 |
101 | #### hash table
102 |
103 | 해시 테이블은 (Key, Value)로 데이터를 저장하는 자료구조 중 하나로 빠르게 데이터를 검색할 수 있는 자료구조이다. 해시 테이블이 빠른 검색속도를 제공하는 이유는 내부적으로 배열(버킷)을 사용하여 데이터를 저장하기 때문이다. 해시 테이블은 각각의 Key값에 해시함수를 적용해 배열의 고유한 index를 생성하고, 이 index를 활용해 값을 저장하거나 검색하게 된다. 여기서 실제 값이 저장되는 장소를 버킷 또는 슬롯이라고 한다.
104 |
105 | 
106 |
107 | 예를 들어, `(Key, Value)쌍` 구조를 가지는 데이터 `("John Smith", "521-1234")`를 크기가 16인 해시 테이블에 저장한다고 하자. 그러면 먼저 `index = hash_function("John Smith") % 16` 연산을 통해 index 값을 계산한다. 그리고 `array[index] = "521-1234"` 로 value를 저장하게 된다. 이러한 구조로 데이터를 저장하면 Key값으로 데이터를 찾을 때 해시 함수를 1번만 수행하면 되므로 매우 빠르게 데이터를 저장/삭제/조회할 수 있다. 해시테이블의 평균 시간복잡도는 O(1)이다.
108 |
109 | > **해시(Hash)값이 충돌하는 경우**
110 |
111 | 만약 "John Smith"를 해시 함수를 돌려 나온 값과 "Sandra Dee"를 해시 함수를 돌려 나온 값이 동일하다면, 아래와 같이 해결할 수 있다.
112 |
113 | **해결방법 1: Separate Chaining(분리 연결법)**
114 |
115 | 
116 |
117 | 동일한 버킷의 데이터에 대해 자료구조를 활용해 추가 메모리를 사용하여 다음 데이터의 주소를 저장하는 방법이다. 동일한 해시 값을 가지면, 동일한 버킷 안에 엔트리를 할당해줘야한다. 이 때, 버킷 내부의 엔트리 값들은 linked list 형태로 이어준다. 이러한 Chaining 방식은 해시 테이블의 확장이 필요없고 간단하게 구현이 가능하며, 손쉽게 삭제할 수 있다는 장점이 있다. 하지만 데이터의 수가 많아지면 동일한 버킷에 chaining되는 데이터가 많아지며 그에 따라 캐시의 효율성이 감소한다는 단점이 있다.
118 |
119 | **해결방법 2: Open Addressing(개방주소법)**
120 |
121 | Open Addressing이란 추가적인 메모리를 사용하는 Chaining 방식과 다르게 비어있는 해시 테이블의 공간을 활용하는 방법이다. Open Addressing을 구현하기 위한 대표적인 방법으로는 3가지 방식이 존재한다.
122 |
123 | - **Linear Probing**: 현재의 버킷 index로부터 고정폭 만큼씩 이동하여 차례대로 검색해 비어 있는 버킷에 데이터를 저장한다.
124 | - **Quadratic Probing**: 해시의 저장순서 폭을 제곱으로 저장하는 방식이다. 예를 들어 처음 충돌이 발생한 경우에는 1만큼 이동하고 그 다음 계속 충돌이 발생하면 2^2, 3^2 칸씩 옮기는 방식이다.
125 | - **Double Hashing Probing**: 해시된 값을 한번 더 해싱하여 해시의 규칙성을 없애버리는 방식이다. 해시된 값을 한번 더 해싱하여 새로운 주소를 할당하기 때문에 다른 방법들보다 많은 연산을 하게 된다.
126 |
127 | 충돌을 방지하는 방법들은 데이터의 규칙성(클러스터링)을 방지하기 위한 방식이지만 공간을 많이 사용한다는 치명적인 단점이 있다. 만약 테이블이 꽉 차있는 경우라면 테이블을 확장해주어야 하는데, 이는 매우 심각한 성능의 저하를 불러오기 때문에 가급적이면 확정을 하지 않도록 테이블을 설계해주어야 한다. (통계적으로 해시 테이블의 공간 사용률이 70% ~ 80%정도가 되면 해시의 충돌이 빈번하게 발생하여 성능이 저하되기 시작한다고 한다.) 또한 해시 테이블에서 자주 사용하게 되는 데이터를 Cache에 적용하면 효율을 높일 수 있다. 자주 hit하게 되는 데이터를 캐시에서 바로 찾음으로써 해시 테이블의 성능을 향상시킬 수 있다.
128 |
129 | > **시간 복잡도**
130 |
131 | 삽입, 삭제, 탐색에 대해 해시 충돌이 일어나지 않는 경우에 $O(1)$, 충돌이 일어난다면 최악의 경우에 $O(N)$의 시간 복잡도를 가진다.
132 |
133 | 왜냐하면 해시 충돌로 인해서 하나의 버킷에 여러 엔트리가 연결되어있는 경우에 모든 엔트리를 탐색해야할 수 있기 때문이다.
134 |
135 | #### References
136 |
137 | - [[자료구조] 해시테이블(HashTable)이란? - MangKyu's Diary](https://mangkyu.tistory.com/102)
138 |
139 | ---
140 |
141 | ## #3
142 |
143 | #### stack
144 |
145 | 
146 |
147 | **LIFO (Last In First Out)** 구조의 자료형으로 한 쪽으로만 데이터를 넣고 뺄 수 있다. `push` 명령으로 데이터를 넣고, `pop` 명령으로 가장 마지막에 들어간 데이터를 빼낸다.
148 |
149 | stack 은 브라우저의 뒤로가기 기능, ctrl + z (되돌리기), 지역 변수와 매개변수를 저장하는 stack 메모리 등에 사용된다. 이외에도 DFS 알고리즘 등 다양한 곳에 사용되는 자료형이다.
150 |
151 | stack 에 데이터가 꽉 차서 더 넣을 공간이 없는데 데이터를 push 하는 경우 `overflow`, 반대로 데이터가 없는데 pop 하는 경우를 `underflow` 라고 한다.
152 |
153 | #### References
154 |
155 | - [[자료구조] 스택, 큐는 무엇인가? - 마이구미](https://mygumi.tistory.com/357)
156 | - [[자료구조] 스택(Stack), 큐(Queue), 덱(Deque) - Choiiis](https://velog.io/@choiiis/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-%EC%8A%A4%ED%83%9DStack%EA%B3%BC-%ED%81%90Queue)
157 |
158 | ---
159 |
160 | ## #4
161 |
162 | #### queue
163 |
164 | 
165 |
166 | **FIFO (First In First Out)** 구조의 자료형으로 출구(front)와 입구(rear or back)가 따로 존재하여 먼저 입력된 데이터가 먼저 반환된다.
167 |
168 | `push` 명령으로 rear 에 자료를 넣는다. rear += 1 되어 다음에 데이터를 받을 메모리를 가리켜야 한다. `pop` 명령으로 front 에서 데이터를 빼낸다. front += 1 되어 다음에 데이터를 반환할 메모리를 가리켜야 한다.
169 |
170 | queue 는 CPU 연산처리 작업대기, 프린터 인쇄, 프로세스 관리 등 들어온 순서를 보장해야하는 경우 사용된다. 이외에도 BFS 알고리즘 등에 사용된다.
171 |
172 | queue 의 rear 가 기리키는 공간에 데이터가 있는데 데이터를 push 하는 경우 `overflow`, 반대로 front 가 가리키는 공간에 데이터가 없는데 pop 하는 경우를 `underflow` 라고 한다.
173 |
174 | #### References
175 |
176 | - [[자료구조] 스택, 큐는 무엇인가? - 마이구미](https://mygumi.tistory.com/357)
177 | - [[자료구조] 스택(Stack), 큐(Queue), 덱(Deque) - Choiiis](https://velog.io/@choiiis/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-%EC%8A%A4%ED%83%9DStack%EA%B3%BC-%ED%81%90Queue)
178 |
179 | ---
180 |
181 | ## #4-1
182 |
183 | #### circular queue
184 |
185 | 
186 |
187 | 크기가 N 인 queue 에서 모든 원소를 다 채우면 rear 는 N-1 을 가리킨다. 이 때, pop 으로 제일 처음 원소를 제거하면 queue 에 남은 공간 1개가 생긴다. 하지만 rear 는 마지막을 가리키고 있기 때문에 더이상 원소를 추가할 수 없다. 이 문제를 해결하기 위해 원형 형태의 `circular queue` 를 사용한다. queue 와 같이 FIFO 구조의 자료형이다.
188 |
189 | 동작 방식은 다음과 같다.
190 |
191 | - 처음에는 front 와 rear 가 같은 메모리를 가리킨다.
192 | - 데이터를 입력하기 위해 rear 는 메모리가 꽉찼는지 검사한다. 꽉찬 경우는 rear 다음 번의 메모리가 front 를 가리키는 경우 (rear + 1 == front) 인데, 꽉차지 않았다면 데이터를 입력하고 rear 는 다음 메모리로 이동한다.
193 | - 데이터를 반환하기 위해 front 는 메모리가 비었는지 검사한다. 빈 경우에는 현재 front 위치와 rear 위치가 같은 경우 (rear == front) 인데, 비지 않았다면 데이터를 반환하고 front 는 다음 메모리로 이동한다.
194 |
195 | #### References
196 |
197 | - [[자료구조] 큐(QUEUE)와 원형큐(CIRCULAR QUEUE) 개념과 구현 - reakwon](https://reakwon.tistory.com/30)
198 |
199 | ---
200 |
201 | ## #5
202 |
203 | #### graph
204 |
205 | 그래프는 정점과 간선으로 이루어진 자료구조이다. 정점 간의 연결관계는 간선으로 나타낸다.
206 |
207 | > **그래프의 종류**
208 |
209 | 
210 |
211 | 간선이 담고있는 정보와 연결 상태에 따라 그래프의 종류가 나뉜다. 두 정점을 연결하는 간선에 방향이 없다면 `무방향 그래프`, 두 정점을 연결하는 간선에 방향이 존재하면 `방향 그래프`라고 부른다. 방향 그래프는 간선의 방향으로만 이동할 수 있다. 두 정점을 이동할 때 비용이 발생하면 `가중치 그래프`로 나타낼 수 있다. 모든 정점이 간선으로 연결된 경우, `완전 그래프`라고 부른다.
212 |
213 | > **그래프 구현 방식**
214 |
215 | 첫 번째로 **인접행렬 방식**이 있다. 노드를 인덱스로 삼는 2차원 배열을 만들어 각 노드가 간선으로 연결되어있으면 배열에 1을 넣어주고, 연결되지 않았다면 0을 넣어주면 된다.
216 |
217 | 두 노드의 연결관계를 조회할 때, $O(1)$ 시간이 걸린다. 그러나 모든 정점에 대해, 간선 정보를 입력해야하므로 초기화에 $O(N^2)$ 시간이 소요된다.
218 |
219 | 노드의 수가 많고, 간선의 수가 적은 그래프의 경우에, 공간을 낭비하게 된다.
220 |
221 | 
222 |
223 | 두 번째로 **인접리스트 방식**이 있다. 그래프의 노드들을 리스트로 표현한다. head 노드와 연결된 노드들을 링크에 달아주면 된다.
224 |
225 | 한 정점에 연결된 노드들의 정보를 얻기 위해서 $O(M)$ 시간이 걸린다.(M은 간선의 수) 간선 정보만 유지하므로, 공간 낭비가 적으나 두 정점이 연결되었는지 확인하기 위해서 $O(M)$ 시간이 걸리며, 구현이 비교적 어렵다.
226 |
227 | > **그래프 용어**
228 |
229 | - `정점(vertice)` : 노드(node)라고도 하며 정점에는 데이터가 저장된다.
230 | - `간선(edge)`: 링크(arcs)라고도 하며 노드간의 관계를 나타낸다.
231 | - `인접 정점(adjacent vertex)` : 간선에 의해 직접 연결된 정점이다.
232 | - `단순 경로(simple-path)` : 경로 중 반복되는 정점이 없는것, 같은 간선을 자나가지 않는 경로이다.
233 | - `차수(degree)` : 무방향 그래프에서 하나의 정점에 인접한 정점의 수이다.
234 | - `진출 차수(out-degree)` : 방향그래프에서 사용되는 용어로 한 노드에서 외부로 향하는 간선의 수를 뜻한다.
235 | - `진입차수(in-degree)` : 방향그래프에서 사용되는 용어로 외부 노드에서 들어오는 간선의 수를 뜻한다.
236 |
237 | #### References
238 |
239 | - [[Algorithm] 자료구조 그래프(Graph)란 무엇인가? - 코딩팩토리](https://coding-factory.tistory.com/610)
240 |
241 | ---
242 |
243 | ## #6
244 |
245 | #### tree
246 |
247 | tree는 그래프의 일종으로, 부모 노드 밑에 여러 자식 노드가 연결되고, 자식 노드 각각에 다시 자식 노드가 연결되는 재귀적 형태의 자료구조이다. 노드들은 서로 다른 자식 노드를 가지며 이때 각 노드는 재사용 되지 않는다. 트리는 다음과 같은 특징을 갖는다.
248 |
249 | - 반드시 하나의 루트 노드만이 존재한다.
250 | - 모든 자식 노드는 한 개의 부모 노드만을 가진다.
251 | - 서로 다른 임의의 두 노드에 대해 두 노드를 연결하는 경로는 유일하다.
252 | - 사이클을 가지는 노드 집합이 존재하지 않는다.
253 | - 노드가 N개인 트리는 항상 N-1개의 간선을 가진다.
254 |
255 | > **트리 용어**
256 |
257 | 
258 |
259 | - `노드(node)`: 트리를 구성하는 기본 원소
260 | - `루트 노드(root node/root)`: 트리에서 부모가 없는 최상위 노드, 트리의 시작점
261 | - `부모 노드(parent node)`: 루트 노드 방향으로 직접 연결된 노드
262 | - `자식 노드(child node)`: 루트 노드 반대 방향으로 직접 연결된 노드
263 | - `형제 노드(siblings node)`: 같은 부모 노드를 갖는 노드들
264 | - `잎 노드(leaf node)/단말 노드(terminal node)`: 자식이 없는 노드
265 | - `경로(path)`: 한 노드에서 다른 한 노드에 이르는 길 사이에 있는 노드들의 순서
266 | - `길이(length)`: 출발 노드에서 도착 노드까지 거치는 노드의 개수
267 | - `깊이(depth)`: 루트 경로의 길이
268 | - `레벨(level)`: 루트 노드(level=1)부터 노드까지 연결된 링크 수의 합
269 | - `높이(height)`: 가장 긴 루트 경로의 길이
270 | - `차수(degree)`: 각 노드의 자식의 개수
271 | - `트리의 차수(degree of tree)`: 트리의 최대 차수 = max[deg1, deg2, ..., degn]
272 | - `크기(size)`: 노드의 개수
273 | - `너비(width)`: 가장 많은 노드를 갖고 있는 레벨의 크기
274 |
275 | #### References
276 |
277 | - [[자료구조] 트리(Tree)란 - HeeJeong Kwon](https://gmlwjd9405.github.io/2018/08/12/data-structure-tree.html)
278 | - [트리의 종류와 이해 - cjmp1](http://www.secmem.org/blog/2019/05/09/%ED%8A%B8%EB%A6%AC%EC%9D%98-%EC%A2%85%EB%A5%98%EC%99%80-%EC%9D%B4%ED%95%B4/)
279 | - [[자료구조] 트리? + 이진 트리 (Binary Tree) - Suyeon's Blog](https://suyeon96.tistory.com/29)
280 | - [트리(그래프) - 나무위키]()
281 |
282 | ---
283 |
284 | ## #6-1
285 |
286 | #### binary tree
287 |
288 | 
289 |
290 | 이진 트리(binary tree)는 각각의 노드가 최대 두 개의 자식 노드를 가지는 트리를 말한다. 즉, 모든 노드의 차수(degree)가 2 이하인 트리를 말한다. 이진 트리의 모든 서브 트리들은 모두 이진 트리이다.
291 |
292 | > **순회(Traversal) 방법**
293 |
294 | - 전위 순회(preorder)
295 | 1. 노드를 방문한다.
296 | 2. 왼쪽 서브 트리를 전위 순회한다.
297 | 3. 오른쪽 서브 트리를 전위 순회한다.
298 | - 중위 순회(inorder)
299 | 1. 왼쪽 서브 트리를 중위 순회한다.
300 | 2. 노드를 방문한다.
301 | 3. 오른쪽 서브 트리를 중위 순회한다.
302 | - 후위 순회(postorder)
303 | 1. 왼쪽 서브 트리를 후위 순회한다.
304 | 2. 오른쪽 서브 트리를 후위 순회한다.
305 | 3. 노드를 방문한다.
306 | - 레벨 순서 순회(level-order)
307 | - 모든 노드를 낮은 레벨부터 차례대로 순회한다. 레벨 순서 순회는 너비 우선 순회(breadth-first traversal)라고도 한다.
308 |
309 | #### References
310 |
311 | - [이진 트리 - 위키백과](https://ko.wikipedia.org/wiki/%EC%9D%B4%EC%A7%84_%ED%8A%B8%EB%A6%AC)
312 | - [이진 탐색 트리: 이론과 소개 - 오늘도 MadPlay!](https://madplay.github.io/post/binary-search-tree)
313 | - [트리 순회 - 위키백과](https://ko.wikipedia.org/wiki/%ED%8A%B8%EB%A6%AC_%EC%88%9C%ED%9A%8C)
314 |
315 | ---
316 |
317 | ## #6-2
318 |
319 | #### full binary tree
320 |
321 | 
322 |
323 | full binary tree는 단말 노드들을 제외한 모든 노드들이 2개의 자식 노드를 가지는 binary tree이다.
324 |
325 | #### References
326 |
327 | - [Binary Tree 종류 - Heap 구현 사전지식 - YABOONG](https://yaboong.github.io/data-structures/2018/02/10/1_binary-tree-1/)
328 |
329 | ---
330 |
331 | ## #6-3
332 |
333 | #### complete binary tree
334 |
335 | 
336 |
337 | 완전 이진 트리(complete binary tree)는 마지막 level을 제외한 나머지 level에 노드들이 가득 차있고, 마지막 level에서 노드는 가장 왼쪽부터 채워지는 형태의 binary tree이다.
338 |
339 | #### References
340 |
341 | - [Binary Tree 종류 - Heap 구현 사전지식 - YABOONG](https://yaboong.github.io/data-structures/2018/02/10/1_binary-tree-1/)
342 |
343 | ---
344 |
345 | ## #6-4
346 |
347 | #### bst(binary search tree)
348 |
349 | 
350 |
351 | 이진 탐색 트리(binary search tree)는 아래의 성질을 갖고 있는 이진 트리이다.
352 |
353 | - 각각의 모든 노드들의 값(key)은 중복된 값이 아니다.
354 | - 노드의 왼쪽 서브트리에는 그 노드의 값보다 작은 값들을 지닌 노드들로 이루어져 있다.
355 | - 노드의 오른쪽 서브트리에는 그 노드의 값보다 큰 값들을 지닌 노드들로 이루어져 있다.
356 | - 좌우 서브트리는 각각이 다시 이진 탐색 트리여야 한다.
357 |
358 | > **탐색(Search)**
359 |
360 | 검색하고자 하는 값을 루트 노드와 먼저 비교하고, 일치할 경우 루트 노드를 리턴한다.
361 |
362 | - 불일치하고 검색하고자 하는 값이 루트 노드의 값보다 작을 경우 왼쪽 서브트리에서 재귀적으로 검색한다.
363 | - 불일치하고 검색하고자 하는 값이 루트 노드의 값보다 큰 경우 오른쪽 서브트리에서 재귀적으로 검색한다.
364 |
365 | > **삽입(Insert)**
366 |
367 | 삽입을 하기 전, 탐색을 수행한다. 트리를 탐색한 후 키와 일치하는 노드가 없으면 마지막 노드에서 키와 노드의 크기를 비교해서 왼쪽이나 오른쪽에 새로운 노드를 삽입한다.
368 |
369 | > **삭제(Delete)**
370 |
371 | 삭제하려는 노드의 자식 수에 따라
372 |
373 | - **자식 노드가 없는 노드(리프 노드) 삭제**: 해당 노드를 단순히 삭제한다.
374 | - **자식 노드가 1개인 노드 삭제**: 해당 노드를 삭제하고 그 위치에 해당 노드의 자식 노드를 대입한다.
375 | - **자식 노드가 2개인 노드 삭제**: 삭제하고자 하는 노드의 값을 해당 노드의 왼쪽 서브트리에서 가장 큰 값으로 변경하거나, 오른쪽 서브트리에서 가장 작은 값으로 변경한 뒤, 해당 노드(왼쪽 서브트리에서 가장 큰 값을 가지는 노드 또는 오른쪽 서브트리에서 가장 작은 값을 가지는 노드)를 삭제한다.
376 |
377 | > **시간 복잡도**
378 |
379 | BST의 탐색, 삽입, 삭제의 복잡도는 모두 $O(h)$이다. (h는 BST의 높이) BST는 평균 시간 복잡도가 $O(\log_2 n)$이지만 최악의 경우 $O(n)$이다. (skewed tree 이면 node의 수만큼 시간이 소요됨)
380 |
381 | 트리가 complete binary tree 거나 full binary tree 이면 $O(\log_2 n)$, skewed tree 이면 $O(n)$의 시간복잡도를 갖는다.
382 |
383 | #### References
384 |
385 | - [이진 탐색 트리 - 위키백과](https://ko.wikipedia.org/wiki/%EC%9D%B4%EC%A7%84_%ED%83%90%EC%83%89_%ED%8A%B8%EB%A6%AC)
386 | - [Binary Search Tree - 불곰](https://brownbears.tistory.com/392)
387 | - [6. Binary Search Tree - JuHy\_](https://ju-hy.tistory.com/90)
388 |
389 | ---
390 |
391 | ## #7
392 |
393 | #### heap(binary heap)
394 |
395 | 최대값 및 최소값을 찾아내는 연산을 빠르게 하기 위해 고안된 완전 이진 트리를 기본으로 한 자료구조로서 다음의 속성을 만족한다.
396 |
397 | > A가 B의 부모 노드이면, A의 키값과 B의 키값 사이에는 대소관계가 성립한다.
398 |
399 | heap의 종류에는 [min heap](#7-1), [max heap](#7-2)이 있다.
400 |
401 | 각 노드의 자식 노드의 최대 개수는 힙의 종류에 따라 다르지만, 대부분의 경우는 자식 노드의 개수가 최대 2개인 이진 힙(binary heap)을 사용한다.
402 |
403 | 힙에서는 가장 높은(혹은 가장 낮은) 우선순위를 가지는 노드가 항상 루트 노드에 오게 되는 특징이 있으며, 이를 응용하여 우선순위 큐와 같은 추상적 자료형을 구현할 수 있다.
404 |
405 | > 이진 힙(binary heap)
406 |
407 | 이진 힙은 다음과 같은 두 가지 특징을 갖는다. 트리를 T, 임의 내부 노드를 v라고 하면 다음과 같다.
408 |
409 | 1. 루트 노드를 제외한 각 내부 노드는 `key(T.parent(v)) < key(v)` 또는 `key(T.parent(v)) > key(v)`이다. (즉, 키 값은 오름차순이거나 내림차순이다.)
410 | 2. 마지막 왼쪽 결합 노드들의 레벨을 제외한 다른 모든 레벨들은 완전 이진 트리를 형성한다.
411 |
412 | 힙 리스트(heap list)로 표현할 때 i번째 노드의 왼쪽 자식 노드의 위치는 2i가 되며, i번째 노드의 오른쪽 자식 노드의 위치는 2i+1이고, 또한 i번째 노드의 부모 노드의 위치는 i/2가 된다.
413 |
414 | 이진 힙의 시간복잡도는 $O(\log n)$이다.
415 |
416 | #### References
417 |
418 | - [힙 (자료 구조) - 위키백과]()
419 |
420 | ---
421 |
422 | ## #7-1
423 |
424 | #### min heap
425 |
426 | 
427 |
428 | 최소 힙(min heap)은 부모 노드의 키 값이 자식 노드의 키 값보다 작거나 같은 완전 이진 트리이다.
429 |
430 | $$
431 | key(부모 노드) \leq key(자식 노드)
432 | $$
433 |
434 | #### References
435 |
436 | - [[자료구조] 힙(heap)이란 - HeeJeong Kwon](https://gmlwjd9405.github.io/2018/05/10/data-structure-heap.html)
437 |
438 | ---
439 |
440 | ## #7-2
441 |
442 | #### max heap
443 |
444 | 
445 |
446 | 최대 힙(max heap)은 부모 노드의 키 값이 자식 노드의 키 값보다 크거나 같은 완전 이진 트리이다.
447 |
448 | $$
449 | key(부모 노드) \geq key(자식 노드)
450 | $$
451 |
452 | #### References
453 |
454 | - [[자료구조] 힙(heap)이란 - HeeJeong Kwon](https://gmlwjd9405.github.io/2018/05/10/data-structure-heap.html)
455 |
456 | ---
457 |
458 | ## #8
459 |
460 | #### Red-black Tree
461 |
462 | > **레드-블랙트리의 정의**
463 |
464 | 
465 |
466 | 레드-블랙 트리(Red-Black Tree)는 이진탐색트리(Binary Search Tree)의 한 종류로, 삽입(insert), 삭제(delete), 검색(retrieval) 연산을 $O(\log N)$에 수행하도록 보장하는 **균형 잡힌 트리**를 말한다. 즉, 트리의 높이가 $\log N$이 되도록 한다.
467 |
468 | 레드-블랙 트리는 **다음의 조건**을 만족한다.
469 |
470 | - 모든 노드는 빨간색 혹은 검은색이다.
471 | - 루트 노드는 검은색이다.
472 | - `NULL` 혹은 `NIL`로 표기된 리프노드는 검정색이다.
473 | - 빨간색 노드의 자식 노드는 검정색이다. 즉, 빨간색 노드가 연속적으로 나올 수 없다.
474 | - 리프노드에서 루트노드까지 가는 경로에서 만나는 검은색 노드의 개수는 같다.
475 |
476 | > **레드-블랙트리가 균형 잡힌 트리인 이유**
477 |
478 | 레드-블랙 트리의 **5번째 조건** 때문인데, 검은색 노드의 개수가 B이고 빨간색 노드가 최소가 되는 경우와 최대가 되는 경우를 생각해보자. 빨간색 노드가 최소가 되려면, 빨간색 노드 자체가 없어야 하고 총 노드의 개수는 B개이다. 빨간색 노드가 최대가 되려면, `검정-빨강-검정-빨강-...`으로 반복되어야 한다. 이 경우 총 노드의 개수는 2B이다.
479 |
480 | 그러므로 최소 경로와 최대 경로의 차이는 2배보다 크지 않으므로 레드-블랙 트리는 균형 잡힌 트리라고 말할 수 있다.
481 |
482 | > **레드-블랙 트리의 연산**
483 |
484 | 레드-블랙 트리의 연산으로 `검색`, `삽입`, `제거`가 있다. 자세한 내용은 [레드-블랙 트리/동작 - 위키백과](https://ko.wikipedia.org/wiki/%EB%A0%88%EB%93%9C-%EB%B8%94%EB%9E%99_%ED%8A%B8%EB%A6%AC#%EB%8F%99%EC%9E%91)를 참고!
485 |
486 | #### References
487 |
488 | - [알고리즘) Red-Black Tree - ZeddiOS](https://zeddios.tistory.com/237)
489 | - [고급 주제 - 코딩인터뷰 완전분석](http://www.yes24.com/Product/Goods/44305533)
490 | - [[레드-블랙 트리 - 위키백과](https://ko.wikipedia.org/wiki/%EB%A0%88%EB%93%9C-%EB%B8%94%EB%9E%99_%ED%8A%B8%EB%A6%AC#%EB%8F%99%EC%9E%91)]
491 |
492 | ---
493 |
494 | ## #9
495 |
496 | #### B-Tree
497 |
498 | > **B-트리의 정의**
499 |
500 | 
501 |
502 | B-트리는 이진 트리(Binary Tree)를 확장해 모든 리프 노드들이 같은 높이를 갖도록 하는 트리이다. 노드 내에 여러 개의 key가 있을 수 있으며, 최대 key의 개수에 따라 2개이면 2차 B-트리, N개면 N차 B-트리라고 부른다.
503 |
504 | B-트리는 **다음의 조건**을 만족한다.
505 |
506 | - 노드의 key의 개수가 N이면, 자식 노드의 개수는 N+1이다.
507 | - 노드 내의 key는 오름차순으로 정렬되어 있다.
508 | - 루트 노드는 2개 이상의 자식을 가져야 한다.
509 | - 루트 노드를 제외한 나머지 노드들은 적어도 최대 M/2개의 key를 가져야 한다.
510 | - M은 B-트리의 차수를 말한다.
511 | - 리프 노드는 모두 같은 레벨에 있어야 한다.
512 |
513 | > **B-트리의 연산**
514 |
515 | B-트리의 연산은 `검색`과 `삽입`, `제거`가 있다. 다음 연산은 B-트리 연산을 이해할 수 있는 자료로 이것을 참고!
516 |
517 | - B-트리 연산 시뮬레이션: [B-Tree Algorithm Visualizations](https://www.cs.usfca.edu/~galles/visualization/BTree.html)
518 | - B-트리 연산 개념 정리: [[자료구조] 그림으로 알아보는 B-Tree - emplam27.log](https://velog.io/@emplam27/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-%EA%B7%B8%EB%A6%BC%EC%9C%BC%EB%A1%9C-%EC%95%8C%EC%95%84%EB%B3%B4%EB%8A%94-B-Tree)
519 |
520 | > **B-트리 vs B+ 트리**
521 |
522 | B+ 트리는 B-트리와 비슷하지만 리프노드가 연결리스트의 형태를 띄어 선형 검색이 가능한 트리이다. 모든 노드에 key와 data가 있는 B 트리와는 달리 B+ 트리는 리프 노드에만 data가 존재한다. 또한 `삽입`과 `제거` 연산 모두 리프 노드에서만 이루어진다.
523 |
524 | #### References
525 |
526 | - [[자료구조] 그림으로 알아보는 B-Tree - emplam27.log](https://velog.io/@emplam27/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-%EA%B7%B8%EB%A6%BC%EC%9C%BC%EB%A1%9C-%EC%95%8C%EC%95%84%EB%B3%B4%EB%8A%94-B-Tree)
527 | - [[자료구조] 그림으로 알아보는 B+Tree - emplam27.log](https://velog.io/@emplam27/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-%EA%B7%B8%EB%A6%BC%EC%9C%BC%EB%A1%9C-%EC%95%8C%EC%95%84%EB%B3%B4%EB%8A%94-B-Plus-Tree)
528 | - [B트리 - 위키백과](https://ko.wikipedia.org/wiki/B_%ED%8A%B8%EB%A6%AC)
529 | - [B-Tree 개념 정리 - Jlog](https://hyungjoon6876.github.io/jlog/2018/07/20/btree.html)
530 |
--------------------------------------------------------------------------------
/answers/8-algorithm.md:
--------------------------------------------------------------------------------
1 | > **📌 질문은 [WeareSoft님의 tech-interview](https://github.com/WeareSoft/tech-interview)를 참고하였습니다.**
2 |
3 | ## Table of Contents
4 |
5 | - [시간, 공간 복잡도](#1)
6 | - Sort Algorithm
7 | - [Bubble Sort](#2-1)
8 | - [Selection Sort](#2-2)
9 | - [Insertion Sort](#2-3)
10 | - [Merge Sort](#2-4)
11 | - [Heap Sort](#2-5)
12 | - [Quick Sort](#2-6)
13 | - [Counting Sort](#2-7)
14 | - [Radix Sort](#2-8)
15 | - [Divide and Conquer](#3)
16 | - [Dynamic Programming](#4)
17 | - [Greedy Algorithm](#5)
18 | - [Graph](#6)
19 | - [Graph Traversal: BFS, DFS](#6-1)
20 | - [Shortest Path](#6-2)
21 | - [Dijkstra](#6-2-1)
22 | - [Floyd-Warshall](#6-2-2)
23 | - [Bellman-Ford](#6-2-3)
24 | - [Minimum Spanning Tree](#6-3)
25 | - [Prim](#6-3-1)
26 | - [Kruskal](#6-3-2)
27 | - [Union-find](#6-4)
28 | - [Topological Sort](#6-5)
29 |
30 | ---
31 |
32 | ## #1
33 |
34 | #### 시간, 공간 복잡도
35 |
36 | 복잡도란 알고리즘의 성능을 평가하는 척도로 시간 복잡도(Time Complexity)와 공간 복잡도(Space Complexity)로 나뉜다.
37 |
38 | - 시간 복잡도(Time Complexity): 알고리즘에 사용되는 연산 횟수의 총량
39 | - 공간 복잡도(Space Complexity): 알고리즘에 사용되는 메모리 공간의 총량
40 |
41 | 즉, 시간 복잡도는 속도에 대한 분석 결과이고, 공간 복잡도는 메모리 사용량에 대한 분석 결과이다.
42 |
43 | 알고리즘의 복잡도는 점근적 표기법으로 나타내는데, 점근적 표기법에는 대표적으로 O(빅오), Ω(오메가), Θ(세타)가 있다.
44 |
45 | - O Notation (빅오 표기법): 점근적 상한선 / 최악의 경우
46 | - Ω Notation (오메가 표기법): 점근적 하한선 / 최상의 경우
47 | - θ Notation (세타 표기법): 점근적 상한선과 점근적 하한선의 교집합 / 평균의 경우
48 |
49 | 일반적으로 최악의 경우의 성능을 측정하는 빅오 표기법을 많이 사용한다.
50 |
51 | 
52 |
53 | #### References
54 |
55 | - [알고리즘의 시간 복잡도와 Big-O 쉽게 이해하기 - Chulgil.Lee](https://blog.chulgil.me/algorithm/)
56 | - [시간복잡도와 공간복잡도(Time Complexity Space Complexity) - 오늘도 MadPlay!](https://madplay.github.io/post/time-complexity-space-complexity)
57 | - [[컴퓨터 알고리즘 성능분석] 점근적 표기법 (Asymptotic Notation) - 될성부른떡잎](https://ledgku.tistory.com/31)
58 |
59 | ---
60 |
61 | ## #2-1
62 |
63 | #### Bubble Sort
64 |
65 | 버블 정렬(Bubble Sort)은 배열의 0번부터 N-1번까지 탐색을 하면서 인접한 칸과 비교하여 swap을 하는 방식의 정렬 알고리즘이다.
66 |
67 | 
68 |
69 | 위의 과정이 버블 정렬을 1회 실시하고 나서의 결과이다. j번째 값과 j+1번째 값을 비교해서 만약 j번째 값이 더 크다면 swap을 해주는 식으로 동작한다.
70 |
71 | > **시간 복잡도**
72 |
73 | $$
74 | O(N^2)
75 | $$
76 |
77 | > **파이썬 구현**
78 |
79 | ```python
80 | def bubbleSort(alist):
81 | for passnum in range(len(alist)-1, 0, -1):
82 | for i in range(passnum):
83 | if alist[i] > alist[i+1]:
84 | temp = alist[i]
85 | alist[i] = alist[i+1]
86 | alist[i+1] = temp
87 | ```
88 |
89 | #### References
90 |
91 | - [[ 정렬 ] 버블정렬 (Bubble Sort) (C++) - 얍문's Coding World..](https://yabmoons.tistory.com/241)
92 | - [버블정렬 - ratsgo's blog](https://ratsgo.github.io/data%20structure&algorithm/2017/11/05/bubblesort/)
93 | - [6.7. The Bubble Sort - Problem Solving with Algorithms and Data Structures using Python](https://runestone.academy/runestone/books/published/pythonds/SortSearch/TheBubbleSort.html)
94 |
95 | ---
96 |
97 | ## #2-2
98 |
99 | #### Selection Sort
100 |
101 | 선택 정렬(Selection Sort)은 위치 변경 횟수를 줄여, 버블 정렬을 일부 개선한 기법이다. 주어진 배열 중에 최댓값을 찾아 정렬되지 않은 배열의 맨 뒤의 값과 자리를 바꾸어나가는 정렬 알고리즘이다. 배열의 맨 뒤부터 차례로 정렬이 된다.
102 |
103 | 
104 |
105 | 버블 정렬은 왼쪽에 있는 값이 비교 대상인 오른쪽에 있는 값보다 크면 자리를 바꿔줬는데 반해, 선택 정렬은 일단 최댓값(혹은 최솟값)을 찾은 뒤에야 이 값을 정해진 위치로 보내주게 된다. 다시 말해 비교 횟수 측면에서는 버블 정렬과 선택 정렬이 같고 둘 모두 $O(n^2)$의 계산 복잡성을 갖지만 자리 이동(swap)측면에서는 선택 정렬이 효율적이다.
106 |
107 | > **시간 복잡도**
108 |
109 | $$
110 | O(N^2)
111 | $$
112 |
113 | > **파이썬 구현**
114 |
115 | ```python
116 | def selectionSort(alist):
117 | for fillslot in range(len(alist)-1, 0, -1):
118 | positionOfMax = 0
119 | for location in range(1, fillslot+1):
120 | if alist[location] > alist[positionOfMax]:
121 | positionOfMax = location
122 |
123 | temp = alist[fillslot]
124 | alist[fillslot] = alist[positionOfMax]
125 | alist[positionOfMax] = temp
126 | ```
127 |
128 | #### References
129 |
130 | - [[ 정렬 ] 선택 정렬 (Selection Sort) (C++) - 얍문's Coding World..](https://yabmoons.tistory.com/242)
131 | - [선택정렬 - ratsgo's blog](https://ratsgo.github.io/data%20structure&algorithm/2017/11/06/selectionsort/)
132 | - [6.8. The Selection Sort - Problem Solving with Algorithms and Data Structures using Python](https://runestone.academy/runestone/books/published/pythonds/SortSearch/TheSelectionSort.html)
133 |
134 | ---
135 |
136 | ## #2-3
137 |
138 | #### Insertion Sort
139 |
140 | 삽입 정렬(Insertion Sort)은 배열의 모든 요소를 배열의 시작부터 끝까지 현재 배열의 요소들과 비교해 가면서 적절한 위치에 삽입하는 정렬 알고리즘이다.
141 |
142 | 
143 |
144 | > **시간 복잡도**
145 |
146 | - 최악의 경우(Worst): $O(N^2)$
147 | - 평균적인 경우(Average): $O(N^2)$
148 | - 최선의 경우(Best): $O(N)$
149 |
150 | > **파이썬 구현**
151 |
152 | ```python
153 | def insertion_sort(collection):
154 | for index in range(1, len(collection)):
155 | while 0 < index and collection[index] < collection[index - 1]:
156 | collection[index], collection[
157 | index - 1] = collection[index - 1], collection[index]
158 | index -= 1
159 |
160 | return collection
161 | ```
162 |
163 | #### References
164 |
165 | - [[ 정렬 ] 삽입 정렬 (Insertion Sort) (C++) - 얍문's Coding World..](https://yabmoons.tistory.com/243)
166 | - [삽입정렬(Insertion Sort) - ratsgo's blog](https://ratsgo.github.io/data%20structure&algorithm/2017/09/06/insmersort/)
167 | - [6.9. The Insertion Sort - Problem Solving with Algorithms and Data Structures using Python](https://runestone.academy/runestone/books/published/pythonds/SortSearch/TheInsertionSort.html)
168 |
169 | ---
170 |
171 | ## #2-4
172 |
173 | #### Merge Sort
174 |
175 | 합병 정렬(Merge Sort)는 배열을 잘게 쪼갠 뒤 둘씩 크기를 비교해 정렬하고 분리된 리스트를 재귀적으로 합쳐서 정렬을 완성하는 정렬 알고리즘이다. 분할된 배열을 저장해둘 공간이 필요해 메모리 소모량이 큰 편이다. 문제를 분리하고 각각을 해결한 후 다시 합치는 Divide & Conquer 방식을 사용한다.
176 |
177 | - Divide: 초기 배열을 2개의 배열로 분할한다.
178 | - Conquer: 각 부분 배열을 재귀적으로 병합 정렬을 사용하여 정렬한다.
179 | - Merge: 부분 배열을 하나의 배열로 결합한다.
180 |
181 | 
182 |
183 | > **시간 복잡도**
184 |
185 | $$
186 | O(N \log N)
187 | $$
188 |
189 | > **파이썬 구현**
190 |
191 | ```python
192 | def merge_sort(list):
193 | if len(list) <= 1:
194 | return list
195 | mid = len(list) // 2
196 | leftList = list[:mid]
197 | rightList = list[mid:]
198 | leftList = merge_sort(leftList)
199 | rightList = merge_sort(rightList)
200 | return merge(leftList, rightList)
201 | ```
202 |
203 | #### References
204 |
205 | - [[ 정렬 ] 병합 정렬 (Merge Sort) (C++) - 얍문's Coding World..](https://yabmoons.tistory.com/245)
206 | - [합병정렬(Merge Sort) - ratsgo's blog](https://ratsgo.github.io/data%20structure&algorithm/2017/10/03/mergesort/)
207 | - [6.11. The Merge Sort - Problem Solving with Algorithms and Data Structures using Python](https://runestone.academy/runestone/books/published/pythonds/SortSearch/TheMergeSort.html)
208 |
209 | ---
210 |
211 | ## #2-5
212 |
213 | #### Heap Sort
214 |
215 | 힙 정렬(Heap Sort)은 완전 이진 트리로 구현되는 정렬 방식으로, 모든 노드가 힙 속성(각 노드의 값이 자신의 자식 노드 값보다 큰 이진 트리)을 만족하도록 재귀적으로 트리 구조를 만들어 정렬을 완성하는 정렬 알고리즘이다.
216 |
217 | 
218 |
219 | > **동작 원리**
220 |
221 | 1. 주어진 원소들로 최대 힙을 구성한다.
222 | 2. 현재 힙의 루트 노드에는 최대값이 존재하게 된다. 루트의 값을 마지막 요소와 바꾼 후, 힙의 사이즈를 하나 줄인다.
223 | 3. 힙의 사이즈가 1보다 크면 위 과정을 반복한다.
224 |
225 | > **시간 복잡도**
226 |
227 | $$
228 | O(N \log N)
229 | $$
230 |
231 | > **파이썬 구현**
232 |
233 | ```python
234 | def heapify(unsorted, index, heap_size):
235 | largest = index
236 | left_index = 2 * index + 1
237 | right_index = 2 * index + 2
238 | if left_index < heap_size and unsorted[left_index] > unsorted[largest]:
239 | largest = left_index
240 | if right_index < heap_size and unsorted[right_index] > unsorted[largest]:
241 | largest = right_index
242 | if largest != index:
243 | unsorted[largest], unsorted[index] = unsorted[index], unsorted[largest]
244 | heapify(unsorted, largest, heap_size)
245 |
246 | def heap_sort(unsorted):
247 | n = len(unsorted)
248 | for i in range(n//2-1, -1, -1):
249 | heapify(unsorted, i, n)
250 | for i in range(n-1, 0, -1):
251 | unsorted[0], unsorted[i] = unsorted[i], unsorted[0]
252 | heapify(unsorted, 0, i)
253 | return unsorted
254 | ```
255 |
256 | #### References
257 |
258 | - [[ 정렬 ] 힙 정렬 (Heap Sort) (C++) - 얍문's Coding World..](https://yabmoons.tistory.com/246)
259 | - [힙 정렬(Heap Sort) - ratsgo's blog](https://ratsgo.github.io/data%20structure&algorithm/2017/09/27/heapsort/)
260 | - [힙정렬(Heap Sort) 알고리즘 :: 마이구미 - 마이구미의 HelloWorld](https://mygumi.tistory.com/310)
261 |
262 | ---
263 |
264 | ## #2-6
265 |
266 | #### Quick Sort
267 |
268 | 퀵 정렬(Quick Sort)는 pivot을 기준으로 pivot 앞에는 pivot보다 작은 값, 뒤에는 큰 값이 오도록 하여 배열을 분할하고, 분할된 두 개 배열 각각에 재귀적으로 이 과정을 반복해 정렬을 완성하는 정렬 알고리즘이다. 합병 정렬과 달리 주어진 배열을 임의로 나누지 않기 때문에 대개는 효율적이지만, pivot이 잘못 선택되면 복잡도가 $O(n^2)$이 될 수도 있다.
269 |
270 | 
271 |
272 | 위의 과정이 퀵 정렬을 1회 실시하고 나서의 결과이다. 54(pivot)를 기준으로 두 개의 배열로 나뉜다.
273 |
274 | > **시간 복잡도**
275 |
276 | - 최악의 경우(Worst): $O(N^2)$
277 | - 평균적인 경우(Average): $O(N \log N)$
278 | - 최선의 경우(Best): $O(N \log N)$
279 |
280 | > **파이썬 구현**
281 |
282 | ```python
283 | def quickSort(alist):
284 | quickSortHelper(alist, 0, len(alist)-1)
285 |
286 | def quickSortHelper(alist, first, last):
287 | if first < last:
288 |
289 | splitpoint = partition(alist, first, last)
290 |
291 | quickSortHelper(alist, first, splitpoint-1)
292 | quickSortHelper(alist, splitpoint+1, last)
293 |
294 |
295 | def partition(alist, first, last):
296 | pivotvalue = alist[first]
297 |
298 | leftmark = first + 1
299 | rightmark = last
300 |
301 | done = False
302 | while not done:
303 |
304 | while leftmark <= rightmark and alist[leftmark] <= pivotvalue:
305 | leftmark = leftmark + 1
306 |
307 | while alist[rightmark] >= pivotvalue and rightmark >= leftmark:
308 | rightmark = rightmark -1
309 |
310 | if rightmark < leftmark:
311 | done = True
312 | else:
313 | temp = alist[leftmark]
314 | alist[leftmark] = alist[rightmark]
315 | alist[rightmark] = temp
316 |
317 | temp = alist[first]
318 | alist[first] = alist[rightmark]
319 | alist[rightmark] = temp
320 |
321 | return rightmark
322 | ```
323 |
324 | #### References
325 |
326 | - [[ 정렬 ] 퀵 정렬(Quick Sort) (C++) - 얍문's Coding World..](https://yabmoons.tistory.com/244)
327 | - [퀵 정렬(Quick Sort) - ratsgo's blog](https://ratsgo.github.io/data%20structure&algorithm/2017/09/28/quicksort/)
328 | - [6.12. The Quick Sort - Problem Solving with Algorithms and Data Structures using Python](https://runestone.academy/runestone/books/published/pythonds/SortSearch/TheQuickSort.html)
329 |
330 | ---
331 |
332 | ## #2-7
333 |
334 | #### Counting Sort
335 |
336 | 계수 정렬(Counting Sort)은 입력값의 빈도를 세어서 이를 결과 리스트의 인덱스로 활용하고 입력 리스트의 요소값에 해당하는 결과 리스트 인덱스 위치에 채워 넣는 방식으로 정렬을 완성하는 정렬 알고리즘이다. 입력 리스트의 최댓값(k)이 커질수록 복잡도가 크게 높아진다.
337 |
338 | 
339 |
340 | > **동작 원리**
341 |
342 | 1. 각 데이터의 개수를 모두 count 한다.
343 | 2. 최솟값부터 각 값까지의 count 누적합을 구한다.
344 | 3. 새로운 배열에 누적합의 개수를 줄여주며 저장한다.
345 |
346 | > **시간 복잡도**
347 |
348 | $$
349 | O(N+k)
350 | $$
351 |
352 | ($k$: 데이터의 최댓값)
353 |
354 | > **파이썬 구현**
355 |
356 | ```python
357 | def counting_sort(A, k):
358 | B = [-1] * len(A)
359 | C = [0] * (k + 1)
360 |
361 | for a in A:
362 | C[a] += 1
363 |
364 | for i in range(k):
365 | C[i+1] += C[i]
366 |
367 | for j in reversed(range(len(A))):
368 | B[C[A[j]] - 1] = A[j]
369 | C[A[j]] -= 1
370 |
371 | return B
372 | ```
373 |
374 | #### References
375 |
376 | - [[ 정렬 ] 카운팅 정렬(Counting Sort) (C++) - 얍문's Coding World..](https://yabmoons.tistory.com/249)
377 | - [카운팅 정렬, 래딕스 정렬 - ratsgo's blog](https://ratsgo.github.io/data%20structure&algorithm/2017/10/16/countingsort/)
378 | - [Counting Sort in C++ - prepinsta](https://prepinsta.com/cpp-program/counting-sort/)
379 |
380 | ---
381 |
382 | ## #2-8
383 |
384 | #### Radix Sort
385 |
386 | 기수 정렬(Radix Sort)은 입력값의 자릿수(d) 각각에 대해 카운팅 정렬을 적용하여 입력 데이터의 최댓값인 k가 커질수록 효율이 떨어지는 카운팅 정렬의 단점을 보완한 정렬 알고리즘이다. 10진법으로 표현된 입력값에 기수 정렬을 적용하면 k 값이 9로 작아진다.
387 |
388 | 
389 |
390 | > **시간 복잡도**
391 |
392 | $$
393 | d \times O(N)
394 | $$
395 |
396 | ($d$: 입력값의 자릿수)
397 |
398 | > **파이썬 구현**
399 |
400 | ```python
401 | from math import log
402 |
403 | def get_digit(number, d, base):
404 | return (number//base**d) % base
405 |
406 | def counting_sort_with_digit(A, d, base):
407 | k = base - 1
408 | B = [-1] * len(A)
409 | C = [0] * (k + 1)
410 | for a in A:
411 | C[get_digit(a, d, base)] += 1
412 | for i in range(k):
413 | C[i+1] += C[i]
414 | for j in reversed(range(len(A))):
415 | B[C[get_digit(A[j], d, base)]-1] = A[j]
416 | C[get_digit(A[j], d, base)] -= 1
417 | return B
418 |
419 | def radix_sort(list, base=10):
420 | digit = int(log(max(list), base)+1)
421 | for d in range(digit):
422 | list = counting_sort_with_digit(list, d, base)
423 | return list
424 | ```
425 |
426 | #### References
427 |
428 | - [[ 정렬 ] 기수 정렬 (Radix Sort) (C++) - 얍문's Coding World..](https://yabmoons.tistory.com/248)
429 | - [카운팅 정렬, 래딕스 정렬 - ratsgo's blog](https://ratsgo.github.io/data%20structure&algorithm/2017/10/16/countingsort/)
430 |
431 | ---
432 |
433 | ## #3
434 |
435 | #### Divide and Conquer
436 |
437 | 분할 정복(Divide and Conquer)은 문제를 **분할**해서 분할한 문제를 **해결**한 다음 결과를 **조합**하는 알고리즘이다. 큰 문제를 작은 문제로 분할한다는 관점에서 하향식 접근 방법으로 문제를 푼다고 볼 수 있다.
438 |
439 | - **분할**: 문제를 동일한 유형의 여러 하위 문제로 나누는 것
440 | - **해결**: 가장 작은 단위의 하위 문제를 해결하는 것
441 | - **조합**: 하위 문제에 대한 결과를 원래 문제에 대한 결과로 조합하는 것
442 |
443 | 분할 정복 알고리즘은 보통 재귀를 사용하여 구현한다. 다음은 분할 정복의 대표적인 문제인 피보나치 수열 코드이다.
444 |
445 | ```python
446 | def fibb(n):
447 | if n <= 1:
448 | return 1
449 | return fibb(n-1) + fibb(n-2)
450 | ```
451 |
452 | #### References
453 |
454 | - [Divide-and-conquer algorithm - Wikipedia](https://en.wikipedia.org/wiki/Divide-and-conquer_algorithm)
455 | - [22장. 분할 정복 - 파이썬 알고리즘 인터뷰](http://www.yes24.com/Product/Goods/91084402)
456 |
457 | ---
458 |
459 | ## #4
460 |
461 | #### Dynamic Programming
462 |
463 | 다이나믹 프로그래밍(Dynamic Programming)은 **중복된 하위 문제들의 결과를 저장**한 후 원래 문제의 결과와 합하는 알고리즘이다.
464 |
465 | 다이나믹 프로그래밍과 분할 정복 알고리즘의 큰 차이점은 **중복된 문제**의 차이이다. 분할 정복 알고리즘을 사용한 병합 정렬이나 퀵 정렬의 경우 하위 문제들이 중복되지 않는다. 반면 다이나믹 프로그래밍은 중복된 하위 문제들의 결과를 저장함으로써 중복 계산을 피한다. 만약 문제가 중복된 하위 문제가 없다면 그 문제는 다이나믹 프로그래밍으로 풀 수 없다.
466 |
467 | 다이나믹 프로그래밍은 크게 상향식과 하향식 접근법으로 나뉜다.
468 |
469 | > **상향식 접근법: 타뷸레이션(Tabulation)**
470 |
471 | 상향식 접근법(Bottom-Up Approach)는 작은 문제의 정답을 이용해 큰 문제의 정답을 푸는 방식이다. 데이터를 테이블 형태로 저장하기 때문에 `타뷸레이션(Tabulation)`이라고 부른다.
472 |
473 | ```python
474 | def fibb(n):
475 | table = [1] * (n+1)
476 | for i in range(2, n+1):
477 | table[i] = table[i-1] + table[i-2]
478 | return table[n]
479 | ```
480 |
481 | > **하향식 접근법: 메모이제이션(Memoization)**
482 |
483 | 하향식 접근법(Top-Down Approach)는 작은 문제의 결과를 얻었는지 확인해가며 문제를 재귀로 풀어가는 방식이다. 분할 정복에서의 재귀 방식과 유사하나 이미 푼 문제인지 검사한다. 이와 같은 방식을 `메모이제이션(Memoization)`이라고 부른다.
484 |
485 | ```python
486 | # 전역 변수로 table과 n이 미리 선언됨
487 | def fibb(n):
488 | if n <= 1:
489 | return 1
490 | if table[n]:
491 | return table[n]
492 | table[n] = fibb(n-1) + fibb(n-2)
493 | return table[n]
494 | ```
495 |
496 | #### References
497 |
498 | - [23장. 다이나믹 프로그래밍 - 파이썬 알고리즘 인터뷰](http://www.yes24.com/Product/Goods/91084402)
499 |
500 | ---
501 |
502 | ## #5
503 |
504 | #### Greedy Algorithm
505 |
506 | 그리디 알고리즘은 현재 단계에서 최선의 방법을 선택하는 알고리즘이다. 가장 큰 값만 선택, 가장 작은 값만 선택 등 한 가지 방법을 정해놓고 다음 단계로 나아가서도 같은 방식으로 문제를 해결한다. 단, 그리디 알고리즘이 적용하기 위해서는 항상 적용될 수 있는지 정당성을 확인해야 한다.
507 |
508 | 가장 적은 동전 개수를 거슬러주는 동전 거스름돈 문제를 생각해보자.
509 |
510 | 1, 5, 10원의 거스름돈이 있다면, **큰 값 먼저 그리디하게** 10원짜리 동전 먼저 되는대로 주고, 다음으로 5원, 남는 돈은 1원으로 처리할 수 있다. 이 경우, 값이 큰 동전들은 값이 작은 동전으로 나눠질 수 있으므로 작은 동전으로 새로운 단위를 만들 수 없기 때문에 그리디 알고리즘이 성립한다.
511 |
512 | 만약 위 문제에서 거스름돈이 1, 7, 10원이라면 어떻게 될까? 14원을 거슬러주기 위해 그리디 알고리즘을 쓴다면 10원 1개, 1원 4개 총 5개의 동전을 쓸 것이다. 하지만 올바른 답은 7원 2개 총 2개가 필요하다. 이 경우, 10원은 7원으로 나눠질 수 없기 때문에 동적 프로그래밍 알고리즘을 사용하는게 적합하다.
513 |
514 | 그리디 알고리즘은 다익스트라 알고리즘 등에도 활용 가능하며, 정렬 등과 함께 사용되는 경우가 많다.
515 |
516 | #### References
517 |
518 | - [Greedy - Heath.log](https://velog.io/@dldydldy75/Greedy-Algorithm)
519 | - [이것이 코딩테스트다 - 나동빈](https://book.naver.com/bookdb/book_detail.nhn?bid=16439154)
520 | - [탐욕(그리디) 알고리즘(greedy algorithm) - zero cho](https://www.zerocho.com/category/Algorithm/post/584ba5c9580277001862f188)
521 |
522 | ---
523 |
524 | ## #6
525 |
526 | #### Graph
527 |
528 | 그래프는 정점과 간선으로 이루어진 자료구조이다. 정점 간의 연결관계는 간선으로 나타낸다.
529 |
530 | ## #6-1
531 |
532 | #### Graph Traversal: BFS, DFS
533 |
534 | > **BFS(Breadth-First Search, 너비우선탐색)**
535 |
536 | BFS는 그래프 전체를 탐색하는 방법 중 하나로써, 현재 확인하는 노드의 인접한 노드들을 먼저 탐색하는 것이다. 시작 정점으로부터 가까운 정점을 먼저 방문하고 멀리 떨어져 있는 정점을 나중에 방문하는 순회하는 방식으로 노드를 탐색한다. 주로 구현은 Queue라는 자료구조에 이웃하는 정점을 다 담아놓고 차례대로 pop을 하는 방식으로 구현한다. 주로 두 노드 사이의 최단 경로 혹은 임의의 경로를 찾고 싶을 때 이 방법을 사용한다.
537 |
538 | - `장점`
539 | - 노드의 수가 적고 깊이가 얕은 경우 빠르게 동작할 수 있다.
540 | - 단순 검색 속도가 깊이 우선 탐색(DFS)보다 빠르다.
541 | - 너비를 우선 탐색하기에 답이 되는 경로가 여러개인 경우에도 최단경로임을 보장한다.
542 | - 최단경로가 존재한다면 어느 한 경로가 무한히 깊어진다해도 최단경로를 반드시 찾을 수 있다.
543 | - `단점`
544 | - 재귀호출의 DFS와는 달리 큐에 다음에 탐색할 정점들을 저장해야 하므로 저장공간이 많이 필요하다.
545 | - 노드의 수가 늘어나면 탐색해야하는 노드 또한 많아지기에 비현실적이다.
546 |
547 | > **DFS(Depth-First Search, 깊이우선탐색)**
548 |
549 | DFS는 그래프 전체를 탐색하는 방법중 하나로써, 시작점 부터 다음 분기(branch)로 넘어가기 전에 해당 분기를 완벽하게 탐색하고 넘어가는 방법이다. 먼저 보이는 노드부터 계속해서 깊이를 늘려가며 탐색하고, 더 이상 탐색할 노드가 없다면 이전 노드로 돌아가서 다른 브랜치를 다시 깊이 파보는 형식을 말한다. Stack이나 재귀함수를 통해서 구현할 수 있는데, 재귀함수가 구현이 간편하다.
550 |
551 | - `장점`
552 | - 현재 경로 상의 노드들만 기억하면 되므로, 저장 공간의 수요가 비교적 적다.
553 | - 목표 노드가 깊은 단계에 있는 경우에도 해를 빨리 구할 수 있다.
554 | - 구현이 너비 우선 탐색(BFS) 보다 간단하다.
555 | - `단점`
556 | - 단순 검색 속도는 너비 우선 탐색(BFS) 보다 느리다.
557 | - 깊이 우선 탐색은 해를 구하면 탐색이 종료되므로, 구한 해가 최단 경로가 된다는 보장이 없다. 목표에 이르는 경로가 다수인 경우, DFS를 통해 구한 해가 최적이 아닐 수 있다. DFS를 사용하여 최단 경로를 구하기 위해서는, 모든 경로를 전부 확인해보아야 한다.
558 |
559 | > **BFS와 DFS의 탐색 순서**
560 |
561 | 
562 |
563 | > **주의해야할 것**
564 |
565 | 노드를 Queue 혹은 Stack에 넣을 때, 방문 여부를 반드시 표시해주어야 한다. 그렇지 않으면, 자료구조에 노드가 중복되게 들어갈 수 있기 때문이다. 방문 표시를 하지 않으면, 심한 경우에는 무한루프에 빠질 수도 있다.
566 |
567 | #### References
568 |
569 | - [[Algorithm] BFS 알고리즘 (Breadth-First Search) - 코딩팩토리](https://coding-factory.tistory.com/612)
570 | - [[Algorithm] DFS 알고리즘 (Depth First Search) - 코딩팩토리](https://coding-factory.tistory.com/611)
571 |
572 | ---
573 |
574 | ## #6-2
575 |
576 | #### Shortest Path
577 |
578 | 한 노드에서 다른 노드로 가는 엣지에 cost 가 있는 그래프가 주어졌을 때, 한 지점 → 목표 지점 또는 모든 지점 → 모든 지점까지 cost 가 가장 적게 드는 최단 경로를 찾는 문제이다.
579 |
580 | 대표적인 알고리즘으로 `Dijkstra`, `Floyd-Warshall`, `Bellman-Ford` 가 있다.
581 |
582 | ## #6-2-1
583 |
584 | #### Dijkstra
585 |
586 | **한 노드**에서 **다른 모든 노드**까지의 최단 거리를 구하는 최단 경로 알고리즘으로 그리디 알고리즘을 사용한다. 단, cost (거리) 는 반드시 음수가 없어야 한다. 이러한 특성 때문에 GPS 길찾기 등에 응용된다.
587 |
588 | 기본 다익스트라 알고리즘은 출발 노드에서 다른 노드로 가는 최단 거리를 기록하는 최단 거리 테이블과 해당 노드 방문 여부를 살피는 visited 테이블을 사용한다.
589 |
590 | > **동작 방식**
591 |
592 | 최단 거리 테이블에 출발 노드는 0, 나머지 노드는 INF 로 초기화한다.
593 |
594 | 1. 먼저 출발 노드를 방문(visited[start] = True)하고 출발 노드에서 갈 수 있는 다른 노드들까지의 거리를 최단 거리 테이블에 기록한다.
595 | 2. 최단 거리 테이블을 보고 가장 거리가 짧은 노드를 방문한다(visited에 기록).
596 | 3. 해당 노드와 연결된 노드 중 방문하지 않은 노드에 대해 현재까지 거리 + 방문하지 않은 노드까지 거리가 최단 거리 테이블의 거리보다 짧다면 최단 거리 테이블을 갱신한다.
597 | 4. 모든 노드에 방문할 때까지 2 와 3 과정을 반복한다.
598 |
599 | 위 알고리즘의 시간 복잡도는 $O(V^2)$ ($V$ : 노드 개수) 이다. 모든 노드에 대해 방문하고 테이블을 모두 살펴보기 때문이다. 이를 개선하기 위해 최단 거리를 찾을 때 `우선순위 큐`를 사용하고 큐에서 꺼낸 거리보다 최단거리 테이블의 값이 더 작다면 방문한 것으로 간주한다. `우선순위 큐`를 사용한 시간 복잡도는 $O(ElogV)$ ($V$: 노드 개수, $E$: 엣지 개수) 이다.
600 |
601 | ```python
602 | import heapq
603 | import sys
604 | input = sys.stdin.readline
605 | INF = int(1e9)
606 |
607 | # 노드 개수, 간선 개수 입력받기
608 | n, m = map(int, input().split())
609 | # 시작 노드 번호 입력받기
610 | start = int(input())
611 | # 각 노드에 연결되어 있는 노드에 대한 정보를 담는 리스트 만들기
612 | graph = [[] for i in range(n+1)]
613 | # 최단 거리 테이블을 모두 무한으로 초기화
614 | distance = [INF] * (n+1)
615 |
616 | # 모든 간선 정보 입력받기
617 | for _ in range(m):
618 | a, b, c = map(int, input().split())
619 | # a 번 노드에서 b 번 노드로 가는 비용이 c 라는 의미
620 | graph[a].append((b, c))
621 |
622 | def dijkstra(start):
623 | q = []
624 | # 시작 노드로 가기 위한 최단 경로는 0 으로 설정하여, 큐에 삽입
625 | heapq.heappush(q, (0, start))
626 | distance[start] = 0
627 | while q: # 큐가 비어있지 않다면
628 | # 가장 최단 거리가 짧은 노드에 대한 정보 꺼내기
629 | dist, now = heapq.heappop(q)
630 | # 현재 노드가 이미 처리된 적이 있는 노드면 무시
631 | if distance[now] < dist:
632 | continue
633 | # 현재 노드와 연결된 다른 인접한 노드들을 확인
634 | for to_other in graph[now]:
635 | cost = dist + to_other[1]
636 | if distance[to_other[0]] > cost:
637 | distance[to_other[0]] = cost
638 | heapq.heappush(q, (cost, to_other[0]))
639 |
640 | # 다익스트라 알고리즘 수행
641 | dijkstra(start)
642 |
643 | # 모든 노드로 가기 위한 최단 거리를 출력
644 | for i in range(1, n+1):
645 | # 도달할 수 없는 경우, 무한으로 출력
646 | if distance[i] == INF:
647 | print("INFINITY")
648 | else:
649 | print(distance[i])
650 | ```
651 |
652 | #### References
653 |
654 | - [Shortest Path - Heath.log](https://velog.io/@dldydldy75/Shortest-Path)
655 | - [이것이 코딩테스트다 - 나동빈](https://book.naver.com/bookdb/book_detail.nhn?bid=16439154)
656 |
657 | ---
658 |
659 | ## #6-2-2
660 |
661 | #### Floyd-Warshall
662 |
663 | 모든 지점에서 모든 지점까지의 최단 경로를 구하는 알고리즘이다.
664 |
665 | A → B 를 거리를 구할 때, 특정 노드 X 를 중간에 거쳐 가는 값과 기존의 최단 경로 테이블 값 중 어느 것이 짧은지 비교하는 것이 핵심이다. 이 과정에서 X 를 모든 노드로 바꿔가며 진행하면 된다.
666 |
667 | 모든 노드에 대해 해당 노드를 거쳐 가는 경우를 계산하므로 플로이드-워셜 알고리즘의 시간 복잡도는 $O(V^3)$($V$: 노드 개수)이다.
668 |
669 | 다익스트라가 그리디한 방식이었다면, 플로이드-워셜은 점화식을 통해 테이블을 갱신하기 때문에 DP 를 사용하는 방식이다.
670 |
671 | $$
672 | D_{ab} = min(D_{ab}, D_{ak} + D_{kb})
673 | $$
674 |
675 | ```python
676 | INF = int(1e9) # 무한을 의미하는 값으로 10 억을 설정
677 |
678 | # 노드의 개수 및 간선의 개수를 입력받기
679 | n = int(input())
680 | m = int(input())
681 | # 2 차원 리스트 (그래프 표현) 를 만들고, 모든 값을 무한으로 초기화
682 | graph = [[INF] * (n+1) for _ in range(n+1)]
683 |
684 | # 자기 자신에서 자기 자신으로 가는 비용은 0 으로 초기화
685 | for i in range(1, n+1):
686 | graph[i][i] = 0
687 |
688 | # 각 간선에 대한 정보를 입력받아, 그 값으로 초기화
689 | for _ in range(m):
690 | # A 에서 B 로 가는 비용은 C 라고 설정
691 | a, b, c = map(int, input().split())
692 | graph[a][b] = c
693 |
694 | # 점화식에 따라 플로이드 워셜 알고리즘을 수행
695 | for k in range(1, n+1):
696 | for a in range(1, n+1):
697 | for b in range(1, n+1):
698 | graph[a][b] = min(graph[a][b], graph[a][k] + graph[k][b])
699 |
700 | # 수행된 결과를 출력
701 | for a in range(1, n+1):
702 | for b in range(1, n+1):
703 | # 도달할 수 없는 경우, 무한으로 출력
704 | if graph[a][b] == INF:
705 | print("INFINITY")
706 | else:
707 | print(graph[a][b], end = ' ')
708 | print()
709 | ```
710 |
711 | #### References
712 |
713 | - [Shortest Path - Heath.log](https://velog.io/@dldydldy75/Shortest-Path)
714 | - [플로이드 와샬 알고리즘 - 안경잡이개발자](https://blog.naver.com/ndb796/221234427842)
715 |
716 | ---
717 |
718 | ## #6-2-3
719 |
720 | #### Bellman-Ford
721 |
722 | 다익스트라 알고리즘은 간선이 음수인 경우 음수 사이클에 빠질 수 있기 때문에 사용할 수 없다. 벨만 포드 알고리즘을 사용하면 음수 사이클을 찾을 수 있다.
723 |
724 | 기본적인 개념은 **모든 엣지**를 거치면서 최단거리를 찾는 것이다. 이 작업을 모든 노드에 대해 진행한다. 시간 복잡도는 $O(VE)$($V$: 노드 개수, $E$: 엣지 개수) 이다.
725 |
726 | 1. 출발 노드를 설정한다.
727 | 2. 최단 거리 테이블을 출발 노드는 0 나머지는 INF 로 초기화한다.
728 | 3. 모든 $E$를 확인하며 테이블 값보다 (현재 노드 최단거리 + 현재노드에서 해당 노드로 가는 거리)가 작다면 테이블을 갱신하는 것을 $V-1$번 반복한다.
729 |
730 | 이후 음수 사이클을 확인하기 위해서는 3의 과정을 한 번만 더 수행한다. 이 때, 테이블이 갱신된다면 음수 사이클이 있는 것이다.
731 |
732 | 다익스트라 알고리즘은 최적의 해를 찾는데 비해, 벨만 포드 알고리즘은 모든 간선을 모든 노드 개수만큼 반복하는 점에서 비효율적이다. 하지만 음수 사이클을 처리할 수 있는 점이 특징이다.
733 |
734 | ```python
735 | import sys
736 | input = sys.input.readline
737 | INF = int(1e9)
738 |
739 | def bf(start):
740 | dist[start] = 0
741 | for i in range(n):
742 | for j in range(m):
743 | cur = edges[j][0]
744 | next_node = edges[j][1]
745 | cost = edges[j][2]
746 | if dist[cur] != INF and dist[next_node] > dist[cur] + cost:
747 | dist[next_node] = dist[cur] + cost
748 | if i == n - 1:
749 | return True
750 | return False
751 |
752 | n, m = map(int, input().split())
753 | edges = []
754 | dist = [INF] * (n+1)
755 |
756 | for _ in range(m):
757 | a, b, c = map(int, input().split())
758 | edges.append(a, b, c)
759 |
760 | start = 1
761 | negative_cycle = bf(start)
762 |
763 | if negative_cycle:
764 | print("negative cycle")
765 | else:
766 | for i in range(2, n+1):
767 | if dist[i] == INF:
768 | print("INF")
769 | else:
770 | print(dist[i])
771 | ```
772 |
773 | #### References
774 |
775 | - [[Python] 최단 경로 - 벨만 포드(Bellman-Ford) 알고리즘 구현하기 - younge.log](https://velog.io/@younge/Python-%EC%B5%9C%EB%8B%A8-%EA%B2%BD%EB%A1%9C-%EB%B2%A8%EB%A7%8C-%ED%8F%AC%EB%93%9CBellman-Ford-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)
776 | - [[알고리즘] 벨만-포드 알고리즘(Bellman-Ford Algorithm) - 딥러닝 공부방](https://deep-learning-study.tistory.com/587)
777 |
778 | ---
779 |
780 | ## #6-3
781 |
782 | #### Minimum Spanning Tree
783 |
784 | > **Spanning Tree**
785 |
786 | Spanning Tree(신장 트리)란 그래프에서 일부 간선을 선택해서 만든, 그래프 내의 모든 정점을 포함하는 트리를 말한다.
787 |
788 | Spanning Tree는 그래프의 `최소 연결 부분 그래프` 이다. `최소 연결`의 의미는 간선의 수가 가장 적다는 것이다. n개의 정점을 가지는 그래프가 모두 이어지기 위해서는 최소 (n-1)개의 간선이 필요하다. n개의 노드를 가지는 그래프에서 (n-1)개의 간선으로 연결되어 있으면 필연적으로 트리 형태가 되고, 이를 spanning tree라고 부른다. 또한, 트리 형식을 만족해야하므로 사이클을 포함해서는 안된다. DFS, BFS을 통해 탐색 도중에 사용된 간선만 모아서 이어주면, 그래프에서 신장 트리를 찾을 수 있다. 하나의 그래프에는 많은 신장 트리가 존재할 수 있다.
789 |
790 | > **Minimum Spanning Tree**
791 |
792 | MST(Minimum Spanning Tree, 최소 신장 트리)란 Spanning Tree 중에서 사용된 간선들의 가중치 합이 최소인 트리를 말한다.
793 |
794 | MST는 간선에 가중치를 고려하여 최소 비용의 Spanning Tree를 선택하는 것을 말한다. 즉, 네트워크(가중치를 간선에 할당한 그래프)에 있는 모든 정점들을 가장 적은 수의 간선과 비용으로 연결하는 것이다.
795 | MST는 **간선의 가중치의 합이 최소**여야 한다는 특징이 있다. 이 외에도 "n개의 정점을 가지는 그래프에 대해 **반드시 (n-1)개의 간선만을 사용**해야 한다"거나 "**사이클이 포함되어서는 안된다**"는 등의 spanning tree의 특징도 포함한다.
796 |
797 | MST를 구현하기 위해서 `Kruskal MST 알고리즘` 혹은 `Prim 알고리즘`이 사용된다. 그래프 내에 적은 숫자의 간선만을 가지는 `희소 그래프(Sparse Graph)`의 경우 Kruskal 알고리즘이 적합하고, 그래프에 간선이 많이 존재하는 `밀집 그래프(Dense Graph)` 의 경우는 Prim 알고리즘이 적합하다.
798 |
799 | #### References
800 |
801 | - [[알고리즘] 최소 신장 트리(MST, Minimum Spanning Tree)란 - heejeong Kwon](https://gmlwjd9405.github.io/2018/08/28/algorithm-mst.html)
802 |
803 | ---
804 |
805 | ## #6-3-1
806 |
807 | #### Prim
808 |
809 | Prim 알고리즘이란 시작 정점에서부터 출발하여 신장트리 집합을 단계적으로 확장해나가는 방법이다. **정점 선택**을 기반으로 하는 알고리즘이며, 이전 단계에서 만들어진 신장 트리를 확장하면서 나아가는 방법이다. Prim 알고리즘의 동작방법은 아래와 같다.
810 |
811 | - 시작 단계에서는 시작 정점만이 MST(최소 비용 신장 트리) 집합에 포함된다.
812 | - 앞 단계에서 만들어진 MST 집합에 인접한 정점들 중에서 최소 간선으로 연결된 정점을 선택하여 트리를 확장한다.
813 | - 즉, 가장 낮은 가중치를 먼저 선택한다.
814 | - 위의 과정을 트리가 (N-1)개의 간선을 가질 때까지 반복한다.
815 |
816 | Prim 알고리즘의 시간 복잡도는, 주 반복문이 정점의 수 n만큼 반복하고, 내부 반복문이 n번 반복되므로, $O(n^2)$이다.
817 |
818 | > **Prim 알고리즘의 수행 단계**
819 |
820 | 
821 |
822 | #### References
823 |
824 | - [[알고리즘] Prim 알고리즘 이란 - heejeong Kwon](https://gmlwjd9405.github.io/2018/08/30/algorithm-prim-mst.html)
825 |
826 | ---
827 |
828 | ## #6-3-2
829 |
830 | #### Kruskal
831 |
832 | Kruskal 알고리즘이란 **간선 선택**을 기반으로 하는 알고리즘으로, 이전 단계에서 만들어진 신장 트리와는 상관없이 무조건 최소 간선만을 선택하는 방법이다. 매 단계마다 사이클을 만들지 않는 최소 간선을 채택하면 된다.
833 |
834 | Kruskal 알고리즘은 탐욕적인 방법(greedy method)을 이용하여, 네트워크(가중치를 간선에 할당한 그래프)의 모든 정점을 최소 비용으로 연결하는 최적 해답을 구하는 방법이다. MST(최소 비용 신장 트리)가 **최소 비용의 간선으로 구성**되며, **사이클을 포함하지 않는다**는 조건에 근거하여, 최적해를 보장할 수 있다. 각 단계에서 사이클을 이루지 않는 최소 비용 간선을 선택하면 된다.
835 |
836 | 주의할 점은 다음 간선을 `이미 선택된 간선들의 집합`에 추가할 때 사이클을 생성하는지를 체크해야 한다는 것이다. 새로운 간선이 `이미 다른 경로에 의해 연결되어 있는 정점들`을 연결할 때 사이클이 형성된다. 즉, 추가할 새로운 간선의 양끝 정점이 같은 집합에 속해 있으면, 사이클이 형성된다. 따라서, 추가하고자 하는 간선의 양끝 정점이 같은 집합에 속해 있는지를 먼저 검사해야 하고, 이때 `union-find 알고리즘`을 사용하여 검사할 수 있다.
837 |
838 | Kruskal 알고리즘의 동작방법은 아래와 같다.
839 |
840 | - 그래프의 간선들을 가중치의 오름차순으로 정렬한다.
841 | - 정렬된 간선 리스트에서 순서대로 사이클을 형성하지 않는 간선을 선택한다.
842 | - 즉, 가장 낮은 가중치를 먼저 선택한다.
843 | - 사이클을 형성하는 간선을 제외한다.
844 | - 해당 간선을 현재의 MST(최소 비용 신장 트리)의 집합에 추가한다.
845 |
846 | Kruskal 알고리즘의 시간 복잡도는 $O(e \log_2 e)$이다.
847 |
848 | > **Kruskal 알고리즘 수행 단계**
849 |
850 | 
851 |
852 | #### References
853 |
854 | - [[알고리즘] Kruskal 알고리즘 이란 - heejeong Kwon](https://gmlwjd9405.github.io/2018/08/29/algorithm-kruskal-mst.html)
855 |
856 | ---
857 |
858 | ## #6-4
859 |
860 | #### Union-find
861 |
862 | `유니온-파인드(Union-find)` 혹은 `서로소 집합(Disjoint Sets)` 자료구조는 서로소 부분 집합들로 나눠진 원소들에 대한 정보를 다루는 자료구조이다. 유니온-파인드 자료구조는 다음과 같이 합집합(Union)과 찾기(Find) 연산을 제공한다.
863 |
864 | - **합집합(Union)**: 두 개의 집합을 하나의 집합으로 합친다.
865 | - 서로 연결할 두 노드 A, B가 있다고 할 때, A와 B의 루트 노드인 A'과 B'을 찾는다.
866 | - A'을 B'의 부모 노드로 혹은 B'을 A'을 부모 노드로 설정한다.
867 | - **찾기(Find)**: 노드가 속한 집합을 반환한다.
868 |
869 | 구현 방법은 [개선된 서로소 집합 알고리즘 (경로 압축) - 이것이 취업을 위한 코딩테스트다](https://github.com/ndb796/python-for-coding-test/blob/master/10/3.py) 구현 코드를 참고!
870 |
871 | > **유니온-파인드 자료구조의 활용**
872 |
873 | 유니온-파인드 자료구조를 이용해 무방향 그래프 내에서의 사이클을 판별할 수 있다. 합집합 연산은 그래프의 간선으로 대응된다고 할 때, 다음과 같은 알고리즘으로 사이클을 판별할 수 있다.
874 |
875 | - 간선으로 연결된 두 노드의 루트 노드를 확인한다.
876 | - 만약 루트 노드가 서로 다르다면 합집합 연산을 수행한다.
877 | - 만약 루트 노드가 같다면 사이클이 발생했다고 판단한다.
878 |
879 | 구현 방법은 [서로소 집합을 활용한 사이클 판별 - 이것이 취업을 위한 코딩테스트다](https://github.com/ndb796/python-for-coding-test/blob/master/10/4.py) 구현 코드를 참고!
880 |
881 | #### References
882 |
883 | - [서로소 집합 자료 구조 - 위키백과](https://ko.wikipedia.org/wiki/%EC%84%9C%EB%A1%9C%EC%86%8C_%EC%A7%91%ED%95%A9_%EC%9E%90%EB%A3%8C_%EA%B5%AC%EC%A1%B0)
884 | - [Chapter 10. 그래프 이론 - 이것이 취업을 위한 코딩테스트다](http://www.yes24.com/Product/Goods/91433923)
885 |
886 | ---
887 |
888 | ## #6-5
889 |
890 | #### Topological Sort
891 |
892 | `위상 정렬(Topological Sort)`란 방향 그래프의 모든 노드를 선행 순서를 지키며 정점을 순서대로 나열하는 것이다. 위상 정렬의 대표적인 예로 대학교 선수과목이 있다. 위상 정렬 알고리즘은 다음과 같다.
893 |
894 | - 진입차수가 0인 노드를 큐에 넣는다.
895 | - 큐가 빌 때가지 다음을 반복한다.
896 | - 큐에서 요소를 꺼내 해당 노드에서 출발하는 간선을 그래프에서 제거한다.
897 | - 새롭게 진입차수가 0이 된 노드를 큐에 넣는다.
898 |
899 | 만약 모든 노드를 방문하기 전에 큐가 빈다면 사이클이 존재한다고 판단할 수 있다. 왜냐하면 사이클이 존재하는 경우 사이클을 형성하는 노드들의 진입차수가 항상 1 이상이므로 큐에 넣을 수가 없기 때문이다.
900 |
901 | 구현 방법은 [위상 정렬 - 이것이 취업을 위한 코딩테스트다](https://github.com/ndb796/python-for-coding-test/blob/master/10/6.py) 구현 코드를 참고!
902 |
903 | > **💡 진입 차수(degree)**
904 | > 노드의 관점에서 들어오는 간선의 개수를 진입 차수(degree)라고 한다.
905 |
906 | #### References
907 |
908 | - [[알고리즘] 위상 정렬(Topological Sort)이란](https://gmlwjd9405.github.io/2018/08/27/algorithm-topological-sort.html)
909 | - [위상정렬 - 위키백과](https://ko.wikipedia.org/wiki/%EC%9C%84%EC%83%81%EC%A0%95%EB%A0%AC)
910 |
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/beta-distribution.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/beta-distribution.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/bias-variance-tradeoff.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/bias-variance-tradeoff.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/confidence-level.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/confidence-level.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/eigen-vector.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/eigen-vector.jpeg
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/eigen-vector.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/eigen-vector.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/facebook-bayes-rule.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/facebook-bayes-rule.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/facebook-probability.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/facebook-probability.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/gamma-distribution.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/gamma-distribution.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/gaussian-normal-distribution.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/gaussian-normal-distribution.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/hypothesis.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/hypothesis.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/probability.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/probability.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/sample-size-formula.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/sample-size-formula.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/underfit-right-overfit.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/underfit-right-overfit.png
--------------------------------------------------------------------------------
/answers/img/1-statistics-math/variance-bias.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/1-statistics-math/variance-bias.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/adjusted-r-square.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/adjusted-r-square.jpg
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/categorical-crossentropy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/categorical-crossentropy.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/classification-and-linear-regression.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/classification-and-linear-regression.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/confidence.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/confidence.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/confusion-matrix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/confusion-matrix.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/curse-of-dimensionality.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/curse-of-dimensionality.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/ensemble.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/ensemble.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/gradient-descent.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/gradient-descent.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/input-space-and-feature-space.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/input-space-and-feature-space.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/kernel-function.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/kernel-function.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/kernel-svm.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/kernel-svm.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/l1-loss.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/l1-loss.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/l1-regularization.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/l1-regularization.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/l2-loss.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/l2-loss.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/l2-regularization.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/l2-regularization.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/lift.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/lift.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/linear-and-logistic-regression.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/linear-and-logistic-regression.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/local-minima-global-minima.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/local-minima-global-minima.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/log-loss.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/log-loss.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/markov-chain.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/markov-chain.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/newton.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/newton.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/norm.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/norm.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/ols.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/ols.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/r-square.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/r-square.jpg
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/random-forest-bagging.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/random-forest-bagging.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/roc-curve.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/roc-curve.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/roc.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/roc.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/rss.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/rss.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/state-transition-diagram.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/state-transition-diagram.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/state-transition-probability.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/state-transition-probability.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/stratified-kfold.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/stratified-kfold.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/support.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/support.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/svm.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/svm.png
--------------------------------------------------------------------------------
/answers/img/2-machine-learning/xor.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/2-machine-learning/xor.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/activation-function.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/activation-function.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/adadelta.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/adadelta.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/adagrad.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/adagrad.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/adam-conclusion.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/adam-conclusion.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/adam.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/adam.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/ai.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/ai.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/backpropagation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/backpropagation.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/batch-normalization-formula.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/batch-normalization-formula.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/batch-normalization.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/batch-normalization.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/bias-example.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/bias-example.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/boltzmann-machine-cell.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/boltzmann-machine-cell.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/boltzmann-machine.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/boltzmann-machine.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/cost-gradient-optima.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/cost-gradient-optima.jpeg
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/cost-gradient.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/cost-gradient.jpeg
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/critical-saddle-point-and-local-minima.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/critical-saddle-point-and-local-minima.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/data-augmentation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/data-augmentation.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/data-normalization.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/data-normalization.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/dropout-nn.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/dropout-nn.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/dropout.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/dropout.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/early-stopping.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/early-stopping.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/gradient-descent-formula.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/gradient-descent-formula.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/he-normal.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/he-normal.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/he-uniform.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/he-uniform.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/how-to-gradient-descent.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/how-to-gradient-descent.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/hyperparameter.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/hyperparameter.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/leaky-relu.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/leaky-relu.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/lecun-normal.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/lecun-normal.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/lecun-uniform.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/lecun-uniform.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/local-and-global-minimum.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/local-and-global-minimum.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/local-minima-problem.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/local-minima-problem.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/momentum-vs-nag.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/momentum-vs-nag.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/momentum.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/momentum.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/nag.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/nag.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/noise-robustness.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/noise-robustness.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/parameter-norm-penalty.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/parameter-norm-penalty.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/parameter-vs-hyperparameter.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/parameter-vs-hyperparameter.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/relu-approximate.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/relu-approximate.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/relu.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/relu.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/rmsprop.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/rmsprop.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/saddle-point.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/saddle-point.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/selu-elu.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/selu-elu.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/sigmoid-formula.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/sigmoid-formula.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/sigmoid.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/sigmoid.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/static-dynamic-graph.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/static-dynamic-graph.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/step-size-problem.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/step-size-problem.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/tanh.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/tanh.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/xavier-normal.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/xavier-normal.png
--------------------------------------------------------------------------------
/answers/img/3-deep-learning/xavier-uniform.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/3-deep-learning/xavier-uniform.png
--------------------------------------------------------------------------------
/answers/img/4-python/array-type.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/4-python/array-type.png
--------------------------------------------------------------------------------
/answers/img/4-python/lambda-function.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/4-python/lambda-function.png
--------------------------------------------------------------------------------
/answers/img/4-python/library.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/4-python/library.png
--------------------------------------------------------------------------------
/answers/img/4-python/namespace.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/4-python/namespace.png
--------------------------------------------------------------------------------
/answers/img/4-python/numpy-array.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/4-python/numpy-array.png
--------------------------------------------------------------------------------
/answers/img/4-python/package.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/4-python/package.png
--------------------------------------------------------------------------------
/answers/img/5-network/3-way-handshake.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/3-way-handshake.png
--------------------------------------------------------------------------------
/answers/img/5-network/4-way-handshake.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/4-way-handshake.png
--------------------------------------------------------------------------------
/answers/img/5-network/browser-access-trip.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/browser-access-trip.png
--------------------------------------------------------------------------------
/answers/img/5-network/bus-topology.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/bus-topology.png
--------------------------------------------------------------------------------
/answers/img/5-network/capsulation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/capsulation.png
--------------------------------------------------------------------------------
/answers/img/5-network/cors.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/cors.png
--------------------------------------------------------------------------------
/answers/img/5-network/data-encapsulation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/data-encapsulation.png
--------------------------------------------------------------------------------
/answers/img/5-network/dns.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/dns.png
--------------------------------------------------------------------------------
/answers/img/5-network/http-request-response.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/http-request-response.png
--------------------------------------------------------------------------------
/answers/img/5-network/ipv4-ipv6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/ipv4-ipv6.png
--------------------------------------------------------------------------------
/answers/img/5-network/mesh-full-topology.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/mesh-full-topology.png
--------------------------------------------------------------------------------
/answers/img/5-network/mesh-part-topology.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/mesh-part-topology.png
--------------------------------------------------------------------------------
/answers/img/5-network/network-class.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/network-class.png
--------------------------------------------------------------------------------
/answers/img/5-network/network-delay.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/network-delay.png
--------------------------------------------------------------------------------
/answers/img/5-network/osi-7-layer.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/osi-7-layer.png
--------------------------------------------------------------------------------
/answers/img/5-network/request-response-header.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/request-response-header.png
--------------------------------------------------------------------------------
/answers/img/5-network/ring-topology.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/ring-topology.png
--------------------------------------------------------------------------------
/answers/img/5-network/router-switch-hub.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/router-switch-hub.png
--------------------------------------------------------------------------------
/answers/img/5-network/routing.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/routing.png
--------------------------------------------------------------------------------
/answers/img/5-network/star-topology.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/star-topology.png
--------------------------------------------------------------------------------
/answers/img/5-network/tcp-ip-hierarchy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/tcp-ip-hierarchy.png
--------------------------------------------------------------------------------
/answers/img/5-network/tcp-segment.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/tcp-segment.png
--------------------------------------------------------------------------------
/answers/img/5-network/udp-segment.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/udp-segment.png
--------------------------------------------------------------------------------
/answers/img/5-network/uri.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/uri.png
--------------------------------------------------------------------------------
/answers/img/5-network/web-socket.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/5-network/web-socket.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/context-switching.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/context-switching.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/demand-paging.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/demand-paging.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/fragmentation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/fragmentation.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/hit-rate.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/hit-rate.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/memory-fragmentation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/memory-fragmentation.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/multi-thread-model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/multi-thread-model.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/paging.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/paging.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/process.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/process.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/scheduling-level.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/scheduling-level.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/segmentation-method.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/segmentation-method.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/segmentation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/segmentation.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/swapping.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/swapping.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/sync-async.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/sync-async.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/thread.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/thread.png
--------------------------------------------------------------------------------
/answers/img/6-operating-system/user-kernel-thread.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/6-operating-system/user-kernel-thread.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/adjacent-list.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/adjacent-list.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/adjacent-matrix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/adjacent-matrix.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/b-tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/b-tree.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/basic-linked-list.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/basic-linked-list.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/binary-tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/binary-tree.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/bst.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/bst.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/circular-linked-list.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/circular-linked-list.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/circular-queue.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/circular-queue.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/complete-binary-tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/complete-binary-tree.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/double-linked-list.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/double-linked-list.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/full-binary-tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/full-binary-tree.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/graph.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/graph.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/hash-table.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/hash-table.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/max-heap.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/max-heap.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/min-heap.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/min-heap.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/queue.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/queue.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/red-black-tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/red-black-tree.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/separate-chaining.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/separate-chaining.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/single-linked-list.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/single-linked-list.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/stack.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/stack.png
--------------------------------------------------------------------------------
/answers/img/7-data-structure/tree-terms.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/7-data-structure/tree-terms.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/bfs-dfs.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/bfs-dfs.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/bubble-sort.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/bubble-sort.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/complexity.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/complexity.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/counting-sort.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/counting-sort.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/floyd.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/floyd.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/heap-sort.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/heap-sort.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/insertion-sort.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/insertion-sort.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/kruskal.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/kruskal.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/merge-sort.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/merge-sort.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/prim.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/prim.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/quick-sort.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/quick-sort.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/radix-sort.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/radix-sort.png
--------------------------------------------------------------------------------
/answers/img/8-algorithm/selection-sort.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/answers/img/8-algorithm/selection-sort.png
--------------------------------------------------------------------------------
/answers/statistics-math-distribution.md:
--------------------------------------------------------------------------------
1 | ## 📝 Table of Contents
2 |
3 | - [베르누이 분포](#1)
4 | - [이항 분포](#2)
5 | - [카테고리 분포](#3)
6 | - [다항 분포](#4)
7 | - [가우시안 정규 분포](#5)
8 | - [t 분포](#6)
9 | - [카이제곱 분포](#7)
10 | - [F 분포](#8)
11 | - [베타 분포](#9)
12 | - [감마 분포](#10)
13 |
14 | ---
15 |
16 | ## #1
17 |
18 | #### 베르누이 분포
19 |
20 | 우선 베르누이 시행이란 결과가 두 가지 중 하나만 나오는 것을 말한다. 베르누이 확률변수는 시행결과가 $0$ 또는 $1$이 나오므로 이산확률변수이다.
21 |
22 | - `pmf` : $Bern(x;\theta) = \theta^x(1-\theta)^{1-x}$
23 | - `expectation` : $E[X] = \theta$
24 | - `variance` : $Var[X] = \theta ( 1-\theta)$
25 |
26 | #### References
27 |
28 | - [확률분포 : 베르누이분포, 이항분포, 카테고리분포, 다항분포 - Fall in Machine-Learning](https://imjuno.tistory.com/entry/basicdistribution)
29 | - [8.2 베르누이분포와 이항분포 - 데이터 사이언스 스쿨](https://datascienceschool.net/02%20mathematics/08.02%20%EB%B2%A0%EB%A5%B4%EB%88%84%EC%9D%B4%EB%B6%84%ED%8F%AC%EC%99%80%20%EC%9D%B4%ED%95%AD%EB%B6%84%ED%8F%AC.html)
30 |
31 | ---
32 |
33 | ## #2
34 |
35 | #### 이항 분포
36 |
37 | 베르누이 시행을 $N$번 시행한 것을 말한다. 예를 들어, 동전 던지기를 10번 던져서 앞면이 나온 횟수를 확률 변수로 둔다. 마찬가지로 시행 결과가 횟수로 나오므로 이산확률변수이다.
38 |
39 | - `pmf` : $Bin(x;N, \theta) = \binom{N}{x} \theta^N (1-\theta)^{N-x}$
40 | - `expectation` : $E[X] = N\theta$
41 | - `variance` : $Var[X] = N\theta ( 1-\theta)$
42 |
43 | #### References
44 |
45 | - [확률분포 : 베르누이분포, 이항분포, 카테고리분포, 다항분포 - Fall in Machine-Learning](https://imjuno.tistory.com/entry/basicdistribution)
46 | - [8.2 베르누이분포와 이항분포 - 데이터 사이언스 스쿨](https://datascienceschool.net/02%20mathematics/08.02%20%EB%B2%A0%EB%A5%B4%EB%88%84%EC%9D%B4%EB%B6%84%ED%8F%AC%EC%99%80%20%EC%9D%B4%ED%95%AD%EB%B6%84%ED%8F%AC.html)
47 |
48 | ---
49 |
50 | ## #3
51 |
52 | #### 카테고리 분포
53 |
54 | 카테고리 분포(Categorical distribution)는 베르누이 분포를 확장한 개념이다. 즉 카테고리 시행(여러개의 카테고리 중 하나를 선택하는 실험)의 결과는 카테고리 분포를 따르게 된다. 카테고리 분포를 누적하면 다항분포를 얻게 된다.
55 |
56 | 카테고리 확률변수는 one-hot vector로 표현할 수 있다. 예를 들어, 주사위의 경우 $K = 6$인 카테고리 분포를 따른다고 표기할 수 있다. 눈이 2인 주사위면이 나왔다고 할때, 이때 카테고리 $RV = [0 , 1, 0, 0, 0, 0]$이 된다. $RV$안의 각 원소들은 베르누이 분포를 따르고, 각각 자신들만의 모수를 갖는다. (RV = Random Variable = 확률변수)
57 |
58 | 카테고리가 $K$개일 때, 카테고리 분포의 확률질량함수는 아래와 같다.
59 |
60 | $$
61 | \text{Cat}(x; \mu) =
62 | \begin{cases}
63 | \mu_1 & \text{if } x = (1, 0, 0, \dots, 0) \\
64 | \mu_2 & \text{if } x = (0, 1, 0, \dots, 0) \\
65 | \mu_3 & \text{if } x = (0, 0, 1, \dots, 0) \\
66 | \vdots & \vdots \\
67 | \mu_K & \text{if } x = (0, 0, 0, \dots, 1)
68 | \end{cases}
69 | $$
70 |
71 | $$\text{Cat}(x; \mu) = \mu_1^{x_1} \mu_2^{x_2} \cdots \mu_K^{x^K} = \prod_{k = 1}^{K} \mu_k^{x^k}$$
72 |
73 | #### References
74 |
75 | - [카테고리 분포와 다항분포 - 계량투자 실험실](https://gem763.github.io/probability%20theory/%EC%B9%B4%ED%85%8C%EA%B3%A0%EB%A6%AC-%EB%B6%84%ED%8F%AC%EC%99%80-%EB%8B%A4%ED%95%AD%EB%B6%84%ED%8F%AC.html)
76 | - [갈아먹는 통계 기초1.확률 분포 정리 - 갈아먹는 머신러닝](https://yeomko.tistory.com/33)
77 |
78 | ---
79 |
80 | ## #4
81 |
82 | #### 다항 분포
83 |
84 | 성공확률이 $\theta$인 베르누이 시행을 n번 반복했을 때의 성공횟수가 이항분포를 따르는 것처럼, 성공확률이 $\theta=(\theta_1 ... \theta_k)$인 카테고리 시행을 $n$번 반복했을 때의 각 카테고리별 성공횟수는 다항분포(Multinomial distribution)을 따르게 된다.
85 |
86 | $$
87 | \left( \begin{matrix}
88 | \text{베르누이 분포} \\
89 | \downarrow \\
90 | \text{이항 분포}
91 | \end{matrix} \right)
92 | \approx
93 | \left( \begin{matrix}
94 | \text{카테고리 분포} \\
95 | \downarrow \\
96 | \text{다항 분포}
97 | \end{matrix} \right)
98 | $$
99 |
100 | 다항분포의 수식은 아래와 같다.
101 |
102 | $$
103 | \text{Mu}(x; N, \mu) = \binom{N}{x} \prod_{k=1}^{K} \mu_k^{x_k} = \binom{N}{x_1, \cdots, x_K} \prod_{k=1}^{K} \mu_k^{x_k}
104 | $$
105 |
106 | > 예를들어, 주사위를 10번 던졌을 때, 1이 1번, 2가 2번, 3이 1번, 4가2번, 5가 3번, 6이 1번 나오는 확률을 계산하고자 한다. 이를 벡터로 나타내면 $(1, 2, 1, 2, 3, 1)$이 된다. 6번을 던졌을 때 $x$ 벡터처럼 나올 조합을 계산해야하며, 수식은 아래와 같다.
107 |
108 | $$\binom{N}{x_{1}, \cdots , x_{K}} = \frac{N!}{x_{1}!, \cdots, x_{K}!} $$
109 |
110 | #### References
111 |
112 | - [카테고리 분포와 다항분포 - 계량투자 실험실](https://gem763.github.io/probability%20theory/%EC%B9%B4%ED%85%8C%EA%B3%A0%EB%A6%AC-%EB%B6%84%ED%8F%AC%EC%99%80-%EB%8B%A4%ED%95%AD%EB%B6%84%ED%8F%AC.html)
113 | - [갈아먹는 통계 기초1.확률 분포 정리 - 갈아먹는 머신러닝](https://yeomko.tistory.com/33)
114 |
115 | ---
116 |
117 | ## #5
118 |
119 | #### 가우시안 정규 분포
120 |
121 | 평균을 중심으로 좌우가 대칭인 종 모양을 그리는 정규분포이다. 정규 분포의 확률 밀도 함수와 그 그래프는 아래와 같다.
122 |
123 | $$
124 | f(x) = \frac{1}{\sigma\sqrt{2\pi}} exp(- \frac{(x - \mu)^2}{2 \sigma^2}), -\infty < x < \infty, -\infty < \mu < \infty, \sigma > 0
125 | $$
126 |
127 | 
128 |
129 | 정규 분포 식에서 변수는 $x$이다. $\sigma$와 $\mu$는 그래프를 종모양으로 만드는데 사용된다. $\mu$는 확률 변수 $X$의 평균이고 $\mu$는확률 변수 $X$의 표준 편차이다. 종 모양의 그래프는 평균을 기준으로 좌우 대칭을 이룬다. 표준 편차가 높을 수록 그래프는 완만한 곡선 형태를 띄게 된다.
130 |
131 | #### References
132 |
133 | - [갈아먹는 통계 기초1.확률 분포 정리 - 갈아먹는 머신러닝](https://yeomko.tistory.com/33)
134 |
135 | ---
136 |
137 | ## #6
138 |
139 | #### t 분포
140 |
141 | t 분포는 정규분포와 같이 중심을 기준으로 좌우 대칭이고 종모양 형태를 갖고 중심은 0으로 고정되어 있는 분포이다.
142 |
143 | 자유도(degree of freedom, df)에 따라 종의 형태가 조금씩 변화한다.
144 |
145 | df는 표본수와 관련이 있는 개념으로, 표본이 많아지면 표준정규분포와 거의 동일한 형태를 보인다.
146 |
147 | $Y \sim t(n)$이면,
148 |
149 | $$
150 | f(y) = \frac{\Gamma\left(\frac{n+1}{2}\right)}{\Gamma\left(\frac{n}{2}\right)\cdot\sqrt{\pi n}}\cdot\left(\frac{n}{y^2+n}\right)^{\frac{n+1}{2}},\quad-\infty < y < \infty
151 | $$
152 |
153 | $$
154 | E[Y] = 0 \quad Var[Y] = \frac{n}{n-2}
155 | $$
156 |
157 | > 감마 함수
158 |
159 | $$
160 | \Gamma(x) = \int_{0}^{\infty}u^{x-1}e^{-u}du
161 | $$
162 |
163 | #### References
164 |
165 | - [8.5 스튜던트 t분포, 카이제곱분포, F분포 - 데이터 사이언스 스쿨](https://datascienceschool.net/02%20mathematics/08.05%20%EC%8A%A4%ED%8A%9C%EB%8D%98%ED%8A%B8%20t%EB%B6%84%ED%8F%AC,%20%EC%B9%B4%EC%9D%B4%EC%A0%9C%EA%B3%B1%EB%B6%84%ED%8F%AC,%20F%EB%B6%84%ED%8F%AC.html)
166 | - [2.4 t-분포(t-distribution, Student's t-distribution) - Must Learning with R](https://wikidocs.net/34009)
167 |
168 | ---
169 |
170 | ## #7
171 |
172 | #### 카이제곱 분포
173 |
174 | 정규 분포의 제곱합은 $\chi^2$ 분포를 따른다.
175 |
176 | $$
177 | Z \sim N(0, 1) \quad \Rightarrow \quad Z^2 \sim \chi^2(df=1) \quad \Rightarrow \quad \sum_{i=1}^{n}Z^2_i \sim \chi^2(df=n)
178 | $$
179 |
180 | #### References
181 |
182 | - [8.5 스튜던트 t분포, 카이제곱분포, F분포 - 데이터 사이언스 스쿨](https://datascienceschool.net/02%20mathematics/08.05%20%EC%8A%A4%ED%8A%9C%EB%8D%98%ED%8A%B8%20t%EB%B6%84%ED%8F%AC,%20%EC%B9%B4%EC%9D%B4%EC%A0%9C%EA%B3%B1%EB%B6%84%ED%8F%AC,%20F%EB%B6%84%ED%8F%AC.html)
183 | - [2.5 카이제곱 분포와 F분포 - Must Learning with R](https://wikidocs.net/34010)
184 |
185 | ---
186 |
187 | ## #8
188 |
189 | #### F 분포
190 |
191 | F 분포는 독립적인 $\chi^2$ 변수의 비가 따르는 분포이다.
192 |
193 | $$
194 | Q_1 \sim \chi^2(n_1), \quad Q_2 \sim \chi^2(n_2) \quad \Rightarrow \quad \frac{Q_1/n_1}{Q_2/n_2} \sim F(n_1, n_2)
195 | $$
196 |
197 | #### References
198 |
199 | - [8.5 스튜던트 t분포, 카이제곱분포, F분포 - 데이터 사이언스 스쿨](https://datascienceschool.net/02%20mathematics/08.05%20%EC%8A%A4%ED%8A%9C%EB%8D%98%ED%8A%B8%20t%EB%B6%84%ED%8F%AC,%20%EC%B9%B4%EC%9D%B4%EC%A0%9C%EA%B3%B1%EB%B6%84%ED%8F%AC,%20F%EB%B6%84%ED%8F%AC.html)
200 | - [2.5 카이제곱 분포와 F분포 - Must Learning with R](https://wikidocs.net/34010)
201 |
202 | ---
203 |
204 | ## #9
205 |
206 | #### 감마 분포
207 |
208 | 감마 분포는 **감마 함수**를 사용하여 전체 **k번의 사건**이 일어날 때까지 **걸리는 시간**을 나타내는 연속 확률분포이다.
209 |
210 | $\theta$와 $k$는 감마 분포의 모수이다.
211 |
212 | 감마 분포는 $0 \sim \infty$까지 값을 가질 수 있으며 모수의 베이지안 추정을 위해 사용된다.
213 |
214 | $$
215 | f(x, k, \theta) = x^{k-1}\frac{e^{-x / \theta}}{\theta^k \Gamma (k)} \quad \text{for x > 0}
216 | $$
217 |
218 | 
219 |
220 | **감마 함수**
221 | **팩토리얼**을 함수로 일반화한 것
222 |
223 | $$
224 | \Gamma (z) = \int_0^\infty t^{z-1} e^{-t} dt \ (\Re \ z > 0)
225 | $$
226 |
227 | $$
228 | \Gamma (n) = (n - 1)!
229 | $$
230 |
231 | #### References
232 |
233 | - [갈아먹는 통계 기초 [1] 확률 분포 정리 - 갈아먹는 머신러닝](https://yeomko.tistory.com/33)
234 | - [8.7 베타분포, 감마분포, 디리클레분포 - datascience school](https://datascienceschool.net/02%20mathematics/08.07%20%EB%B2%A0%ED%83%80%EB%B6%84%ED%8F%AC,%20%EA%B0%90%EB%A7%88%EB%B6%84%ED%8F%AC,%20%EB%94%94%EB%A6%AC%ED%81%B4%EB%A0%88%20%EB%B6%84%ED%8F%AC.html)
235 |
236 | ---
237 |
238 | ## #10
239 |
240 | #### 베타 분포
241 |
242 | 베타 분포는 두 모수 $a$, $b$ 에 대한 **베타 함수**를 나타내는 연속확률분포이다.
243 |
244 | 베타 함수는 이항 계수(조합, combination 으로도 불림) 를 나타내는 함수인데, 이항 계수는 팩토리얼로 이루어져있기 때문에 베타 함수는 감마 함수로 나타낼 수 있다.
245 |
246 | 베타 분포의 값은 $0 \sim 1$사이이며 감마 분포와 마찬가지로 베이지안 추정을 위해 사용된다.
247 |
248 | $$
249 | Beta(x; a, b) = \frac{\Gamma(\alpha + \beta )}{\Gamma ( \alpha ) \Gamma ( \beta )} x^{\alpha - 1} (1 - x)^{\beta - 1}
250 | $$
251 |
252 | 
253 |
254 | #### References
255 |
256 | - [갈아먹는 통계 기초 [1] 확률 분포 정리 - 갈아먹는 머신러닝](https://yeomko.tistory.com/33)
257 | - [8.7 베타분포, 감마분포, 디리클레분포 - datascience school](https://datascienceschool.net/02%20mathematics/08.07%20%EB%B2%A0%ED%83%80%EB%B6%84%ED%8F%AC,%20%EA%B0%90%EB%A7%88%EB%B6%84%ED%8F%AC,%20%EB%94%94%EB%A6%AC%ED%81%B4%EB%A0%88%20%EB%B6%84%ED%8F%AC.html)
258 |
--------------------------------------------------------------------------------
/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boost-devs/ai-tech-interview/72243b14374e25348a0532b6f6a1d43ed37691e0/logo.png
--------------------------------------------------------------------------------
5 | 
6 | 
7 | 
8 | 
9 |