diff --git a/reference/deque.py b/Algorithm_with_DataStructure/deque.py
similarity index 100%
rename from reference/deque.py
rename to Algorithm_with_DataStructure/deque.py
diff --git a/reference/dictionary.py b/Algorithm_with_DataStructure/dictionary.py
similarity index 100%
rename from reference/dictionary.py
rename to Algorithm_with_DataStructure/dictionary.py
diff --git a/reference/heapq.py b/Algorithm_with_DataStructure/heapq.py
similarity index 100%
rename from reference/heapq.py
rename to Algorithm_with_DataStructure/heapq.py
diff --git a/reference/list.py b/Algorithm_with_DataStructure/list.py
similarity index 100%
rename from reference/list.py
rename to Algorithm_with_DataStructure/list.py
diff --git a/reference/set.py b/Algorithm_with_DataStructure/set.py
similarity index 100%
rename from reference/set.py
rename to Algorithm_with_DataStructure/set.py
diff --git a/Algorithm_with_DataStructure/tree_adjacentlist.py b/Algorithm_with_DataStructure/tree_adjacentlist.py
new file mode 100644
index 0000000..b9b0f3c
--- /dev/null
+++ b/Algorithm_with_DataStructure/tree_adjacentlist.py
@@ -0,0 +1,57 @@
+"""
+ 트리를 인접 리스트로 구현하는 예시입니다.
+
+ 인접 리스트(adjacency list)는 그래프의 각 정점에 인접한(즉, 직접 연결된) 정점의 리스트를 저장하여 그래프를 표현하는 방식입니다. 인접 리스트의 기본 개념은 각 노드 i의 모든 이웃을 리스트로 관리하는 것입니다.
+
+ 트리도 사이클이 없는 그래프의 한 형태이므로, 인접 리스트로 구현이 가능합니다. 트리는 일반적으로 부모 노드와 자식 노드 간의 관계를 가지며, 이를 인접 리스트로 표현할 때는 각 노드를 키로하고, 그 노드의 자식들을 값으로 가지는 리스트로 표현합니다.
+
+ 도식화:
+ 예를 들어, 다음과 같은 트리를 생각해 봅시다.
+ 1
+ / \
+ 2 3
+ / \
+ 4 5
+
+ 이 트리를 인접 리스트로 표현하면 다음과 같습니다.
+ {
+ 1: [2, 3],
+ 2: [4, 5],
+ 3: [],
+ 4: [],
+ 5: []
+ }
+
+ 여기서 1이라는 키에는 [2, 3]이라는 값이 연결되어 있습니다. 이는 노드 1이 노드 2와 3과 연결되어 있음을 나타냅니다. 비슷하게, 노드 2는 노드 4와 5와 연결되어 있습니다.
+
+ 시간 복잡도:
+ - 노드를 찾는 작업: O(1)
+ - 노드의 인접 리스트를 순회하는 작업: O(deg(v)) [deg(v)는 노드 v의 차수(degree)]
+
+ 즉, 트리를 순회하는 총 시간 복잡도는 O(N)이며, N은 트리의 노드 수입니다. 모든 노드를 정확히 한 번씩 방문하기 때문입니다.
+"""
+
+# 트리를 인접 리스트로 표현
+tree = {
+ 1: [2, 3],
+ 2: [4, 5],
+ 3: [],
+ 4: [],
+ 5: []
+}
+
+def print_tree(t, root):
+ """
+ 주어진 루트에서 시작하여 트리를 출력합니다.
+ """
+ print(root, end=' ')
+ for child in t[root]:
+ print_tree(t, child)
+
+print("Tree traversal:")
+print_tree(tree, 1) # 1 2 4 5 3
+
+"""
+위 함수에서 트리를 순회하는 방식은 깊이 우선 탐색(DFS)과 유사합니다.
+루트 노드에서 시작해서 자식 노드로 재귀적으로 이동하면서 값을 출력합니다.
+"""
diff --git a/Algorithm_with_DataStructure/tree_array.py b/Algorithm_with_DataStructure/tree_array.py
new file mode 100644
index 0000000..d754e70
--- /dev/null
+++ b/Algorithm_with_DataStructure/tree_array.py
@@ -0,0 +1,44 @@
+# 트리를 배열로 구현하는 예시:
+
+# 트리는 일반적으로 노드와 간선으로 구성되며, 노드는 부모-자식 관계를 가집니다.
+# 배열로 트리를 구현할 때, 인덱스를 활용해 부모 노드와 자식 노드 간의 관계를 표현합니다.
+# 예를 들어, 인덱스 i의 노드의 왼쪽 자식 노드는 2*i, 오른쪽 자식 노드는 2*i + 1로 표현할 수 있습니다.
+# 이 방법은 O(1)의 시간 복잡도를 가지며, 부모 노드와 자식 노드 간의 관계를 빠르게 파악할 수 있습니다.
+# 그러나 모든 노드가 채워져 있지 않다면 메모리가 낭비될 수 있습니다.
+
+# 도식화:
+# 예를 들어, 다음과 같은 트리를 생각해 봅시다.
+# 1
+# / \
+# 2 3
+# / \ / \
+# 4 5 6 7
+# 이 트리를 배열로 표현하면 다음과 같습니다.
+# [None, 1, 2, 3, 4, 5, 6, 7]
+# (None은 트리의 루트가 1번 인덱스에 위치하도록 하기 위한 dummy 데이터입니다.)
+
+# 트리를 배열로 표현
+tree = [None, 1, 2, 3, 4, 5, 6, 7]
+
+def get_left_child_idx(idx):
+ return 2 * idx
+
+def get_right_child_idx(idx):
+ return 2 * idx + 1
+
+# 루트 노드의 값 출력
+print("Root node:", tree[1])
+
+# 루트 노드의 왼쪽 자식 노드 값 출력
+left_idx = get_left_child_idx(1)
+print("Left child of root node:", tree[left_idx])
+
+# 루트 노드의 오른쪽 자식 노드 값 출력
+right_idx = get_right_child_idx(1)
+print("Right child of root node:", tree[right_idx])
+
+# 특정 노드 (예: 인덱스 3)의 왼쪽과 오른쪽 자식 노드 값 출력
+node_idx = 3
+print(f"Node at index {node_idx}:", tree[node_idx])
+print(f"Left child of node at index {node_idx}:", tree[get_left_child_idx(node_idx)])
+print(f"Right child of node at index {node_idx}:", tree[get_right_child_idx(node_idx)])
diff --git a/Algorithm_with_DataStructure/tree_travel.py b/Algorithm_with_DataStructure/tree_travel.py
new file mode 100644
index 0000000..4e6ec08
--- /dev/null
+++ b/Algorithm_with_DataStructure/tree_travel.py
@@ -0,0 +1,125 @@
+class Node:
+ def __init__(self, item):
+ self.data = item
+ self.left = self.right = None
+
+
+# 트리 순회의 개념: 트리의 모든 노드를 체계적으로 방문하는 것입니다.
+# 사용되는 경우: 트리 구조의 모든 원소를 접근해야 할 때 사용됩니다. 예를 들어, 모든 원소를 출력하거나 합계를 구할 때 등입니다.
+# 시간 복잡도: O(n). 모든 노드를 정확히 한 번씩 방문합니다.
+
+# 도식화된 트리:
+# 1
+# / \
+# 2 3
+# / \
+# 4 5
+
+"""
+PreOrder 순회과정
+
+ printPreorder(tree.root); -> printPreorder(1)
+ 출력: 1
+ printPreorder(1->left); -> printPreorder(2)
+ 출력: 2
+ printPreorder(2->left); -> printPreorder(4)
+ 출력: 4
+ printPreorder(4->left); -> printPreorder(nullptr)
+ printPreorder(4->right); -> printPreorder(nullptr)
+ printPreorder(2->right); -> printPreorder(5)
+ 출력: 5
+ printPreorder(5->left); -> printPreorder(nullptr)
+ printPreorder(5->right); -> printPreorder(nullptr)
+ printPreorder(1->right); -> printPreorder(3)
+ 출력: 3
+ printPreorder(3->left); -> printPreorder(nullptr)
+ printPreorder(3->right); -> printPreorder(nullptr)
+"""
+
+"""
+PostOrder 순회과정
+
+ printPostorder(tree.root); -> printPostorder(1)
+ printPostorder(1->left); -> printPostorder(2)
+ printPostorder(2->left); -> printPostorder(4)
+ printPostorder(4->left); -> printPostorder(nullptr)
+ printPostorder(4->right); -> printPostorder(nullptr)
+ 출력: 4
+ printPostorder(2->right); -> printPostorder(5)
+ printPostorder(5->left); -> printPostorder(nullptr)
+ printPostorder(5->right); -> printPostorder(nullptr)
+ 출력: 5
+ 출력: 2
+ printPostorder(1->right); -> printPostorder(3)
+ printPostorder(3->left); -> printPostorder(nullptr)
+ printPostorder(3->right); -> printPostorder(nullptr)
+ 출력: 3
+ 출력: 1
+"""
+
+"""
+InOrder 순회과정
+
+ printInorder(tree.root); -> printInorder(1)
+ printInorder(1->left); -> printInorder(2)
+ printInorder(2->left); -> printInorder(4)
+ printInorder(4->left); -> printInorder(nullptr)
+ 출력: 4
+ printInorder(4->right); -> printInorder(nullptr)
+ 출력: 2
+ printInorder(2->right); -> printInorder(5)
+ printInorder(5->left); -> printInorder(nullptr)
+ 출력: 5
+ printInorder(5->right); -> printInorder(nullptr)
+ 출력: 1
+ printInorder(1->right); -> printInorder(3)
+ printInorder(3->left); -> printInorder(nullptr)
+ 출력: 3
+ printInorder(3->right); -> printInorder(nullptr)
+"""
+
+class BinaryTree:
+ def __init__(self, root):
+ self.root = Node(root)
+
+ # 전위 순회: 루트 -> 왼쪽 서브트리 -> 오른쪽 서브트리
+ def print_preorder(self, node):
+ if node is None:
+ return
+ print(node.data, end=" ")
+ self.print_preorder(node.left)
+ self.print_preorder(node.right)
+
+ # 중위 순회: 왼쪽 서브트리 -> 루트 -> 오른쪽 서브트리
+ def print_inorder(self, node):
+ if node is None:
+ return
+ self.print_inorder(node.left)
+ print(node.data, end=" ")
+ self.print_inorder(node.right)
+
+ # 후위 순회: 왼쪽 서브트리 -> 오른쪽 서브트리 -> 루트
+ def print_postorder(self, node):
+ if node is None:
+ return
+ self.print_postorder(node.left)
+ self.print_postorder(node.right)
+ print(node.data, end=" ")
+
+
+# 예시 사용
+tree = BinaryTree(1)
+tree.root.left = Node(2)
+tree.root.right = Node(3)
+tree.root.left.left = Node(4)
+tree.root.left.right = Node(5)
+
+# 출력 결과는 모든 노드를 방문한 순서를 나타냅니다.
+print("Preorder: ")
+tree.print_preorder(tree.root) # 출력: 1 2 4 5 3
+
+print("\nInorder: ")
+tree.print_inorder(tree.root) # 출력: 4 2 5 1 3
+
+print("\nPostorder: ")
+tree.print_postorder(tree.root) # 출력: 4 5 2 3 1
diff --git a/Coding_Test_Success_Guide.md b/Coding_Test_Success_Guide.md
new file mode 100644
index 0000000..48275dc
--- /dev/null
+++ b/Coding_Test_Success_Guide.md
@@ -0,0 +1,47 @@
+# 코딩테스트 합격자 되기 - 챕터별 요약 및 기타공부자료
+
+**저자**: 박경록
+
+
+
+## 챕터
+
+| 챕터 | 링크 |
+|---------|------|
+| 03 알고리즘의 효율 분석 | [Link](https://cafe.naver.com/dremdeveloper/994) |
+| 04 코딩 테스트 필수 문법 | [Link](https://cafe.naver.com/dremdeveloper/995) |
+| 05 배열 | [Link](https://cafe.naver.com/dremdeveloper/1007) |
+| 06 스택 | [Link](https://cafe.naver.com/dremdeveloper/1011) |
+| 07 큐 | [Link](https://cafe.naver.com/dremdeveloper/1015) |
+| 08 해시 | [Link](https://cafe.naver.com/dremdeveloper/1040) |
+| 09 트리 | [Link](https://cafe.naver.com/dremdeveloper/1042) |
+| 10 집합 | [Link](https://cafe.naver.com/dremdeveloper/1044) |
+| 11 그래프(탐색) | [Link](https://cafe.naver.com/dremdeveloper/1045) |
+| 11장 그래프(최소 경로) | [Link](https://cafe.naver.com/dremdeveloper/1046) |
+| 12장 백트래킹 | [Link](https://cafe.naver.com/dremdeveloper/1048) |
+| 13장 정렬 | [Link](https://cafe.naver.com/dremdeveloper/1049) |
+| 14장 시뮬레이션 | [Link](https://cafe.naver.com/dremdeveloper/1050) |
+| 15장 동적 계획법 | [Link](https://cafe.naver.com/dremdeveloper/1051) |
+| 16장 그리디 | [Link](https://cafe.naver.com/dremdeveloper/1052) |
+
+## GPT를 활용한 알고리즘 공부
+
+| 챕터 | 링크 |
+|---------|------|
+| 재귀함수 | [Link](https://cafe.naver.com/dremdeveloper/1053) |
+| 최단경로 알고리즘 | [Link](https://cafe.naver.com/dremdeveloper/1054) |
+
+
+## 공부자료
+| 제목 | 링크 |
+|---------|------|
+| 저자 깃허브 | [Link](https://github.com/dremdeveloper) |
+| 책 무료보기 | [Link](https://wikidocs.net/book/13314) |
+| 공부자료 정리 | [Link](https://github.com/dremdeveloper/codingtest_python/blob/main/community.md) |
+| 저자 카톡방 |[Link](https://open.kakao.com/o/gX0WnTCf) |
+
+
+
+
+
+
diff --git a/README.md b/README.md
index af526b8..8bdc3f8 100644
--- a/README.md
+++ b/README.md
@@ -1,20 +1,28 @@
-# 코딩 테스트 합격자 되기(파이썬 편)
-- 프로그래머스에서 엄선한 기출문제에 대한 상세한 풀이 제공
-- 들고 다닐수 있는 요약노트 제공
-- 실전문제 위주로 출제왼 기출문제 5회본 제공
-
-
+# 코딩 테스트 합격자 되기(파이썬 편)-판매 시작
+| 서점 | 구매링크 |
+| ---------- | ---------------------------------------------- |
+| 무료 미리보기(~179p) | https://wikidocs.net/book/13314 |
+|교보문고 |https://bit.ly/3MlKPPN|
+|알라딘 |https://bit.ly/47bm7ti|
+|예스|https://www.yes24.com/Product/Goods/123272392|
+|정오표|[https://docs.google.com/spreadsheets/d/1BPAmoaDmn-RRBjk8O468M_v3WnI46UaX0N_0vs0pZCk/edit#gid=0](https://github.com/dremdeveloper/codingtest_python/blob/main/%EC%A0%95%EC%98%A4%ED%91%9C.md)|
+
+
+
+
+
# 진행중인 이벤트
| Event | 세부내용 |기간 |
| ---------- | ---------------------------------------------- |---------------------------------------------- |
-|코딩테스트 스터디 |[참여방법 및 스터디 세부사항](https://cafe.naver.com/dremdeveloper/901) | 상시 |
-|코테 정리노트 증정(100프로 당첨) |[참여하러가기](https://rabbit.prosell.kr/m/bbs/Jonbeo/1 ) | 9월27~ |
+|코딩테스트 스터디 |[참여방법 및 스터디 세부사항](https://cafe.naver.com/dremdeveloper/948) | 상시 |
-# 코딩테스트 소통공간(저자가 직접운영)
- - 카카오톡 오픈채팅 : https://open.kakao.com/o/gX0WnTCf
+# 코딩테스트 소통공간(저자가 직접운영)
+| Title | Description |
+| ---------- | ---------------------------------------------- |
+|카카오톡 오픈채팅 |[클릭](https://open.kakao.com/o/gX0WnTCf) |
@@ -25,8 +33,8 @@
| ---------- | ---------------------------------------------- |
|Cafe |http://cafe.naver.com/dremdeveloper |
|Business Mail |ultrasuperrok@gmail.com |
-
-
+|Codingtest Java |https://github.com/dremdeveloper/codingtest_java |
+|Codingtest CPP |https://github.com/dremdeveloper/codingtest_cpp |
# 폴더 구조
- 깃 허브의 폴더 구조에 대한 설명
diff --git a/community.md b/community.md
new file mode 100644
index 0000000..e8579c2
--- /dev/null
+++ b/community.md
@@ -0,0 +1,51 @@
+# 📚 코딩 테스트 합격자 되기
+
+
+
+
+## 🎮스터디 모집 / 정보공유 / 책 추천
+직접 스터디원을 모집하거나 정보를 공유하실 수도 있고, 편하게 참여만 하셔도 됩니다.
+[링크](https://docs.google.com/spreadsheets/d/1-p4O5G75vnG6jyxnkY5zamydzgro_68Z21NU5Eumxfc/edit?usp=sharing)
+
+
+## 📝 정오표 및 오탈자 제보
+
+- 최신의 정정사항이나 업데이트를 확인하려면 여기를 클릭하세요!
+
👉 [**파이썬 편 정오표**](https://github.com/dremdeveloper/codingtest_python/blob/main/%EC%A0%95%EC%98%A4%ED%91%9C.md)
+
👉 [**오탈자 제보(C++/파이썬)**](https://forms.gle/xqnz13aaHgdBbhtDA)
+
+
+## 🎥책 소개 및 영상 강의
+| 제목 | 링크 |
+|---------|------|
+| 프로그래머스 특강 | [Link](https://youtu.be/9HNCr_fxtlc?si=hL5NYmHMV4j56AIt) |
+| 책 소개| [Link](https://youtu.be/CLXFgptB81M) |
+| 코딩 테스트 합격자 되기 강의(C++편이지만 개념강의 이므로 다 들으셔도 됩니다.)| [Link](https://inf.run/H9yxm) |
+
+
+
+## 🛒 책 구매
+
+| 책 제목 | 링크 |
+| --- | --- |
+| C++ 편 | [구매](https://www.yes24.com/Product/Goods/123272392) |
+| 파이썬 편 | [구매](https://www.yes24.com/Product/Goods/123272392) [미리보기](https://wikidocs.net/book/13314) |
+| 자바 편 | [구매](https://product.kyobobook.co.kr/detail/S000212576322) [미리보기](https://wikidocs.net/book/14549) |
+
+
+## 💬 커뮤니티 참여
+| 항목 | 설명 | 링크 |
+| --- | --- | --- |
+| 오픈 카톡방 | - 독자 여러분과 실시간으로 소통할 수 있는 공간입니다.
- 개발 관련 얘기 및 상담을 자유롭게 진행할 수 있습니다. | [링크](https://open.kakao.com/o/gX0WnTCf) |
+| 네이버 카페 | 많은 알고리즘 자료가 있습니다. | [링크](https://cafe.naver.com/dremdeveloper) |
+
+
+
+## 🚘 깃허브
+| 책 제목 | 링크 |
+| --- | --- |
+| 파이썬 편 | [링크](https://github.com/dremdeveloper/codingtest_python) |
+| C++ 편 | [링크](https://github.com/dremdeveloper/codingtest_cpp) |
+
+
+
diff --git a/discord.md b/discord.md
new file mode 100644
index 0000000..e875e25
--- /dev/null
+++ b/discord.md
@@ -0,0 +1,89 @@
+
+# Discord 음성채널 설명서
+
+## 목차
+1. 음성채널이란?
+2. Discord 가입 및 설정
+3. 음성채널에 접속하기
+4. 음성채널에서 할 수 있는 일
+5. **모각코란?**
+6. 문제 해결
+
+---
+
+디스코드를 이미 어느정도 아시는 분은 **5. 모각코란**로 바로 가주시면 됩니다.
+
+## 1. 음성채널이란?
+
+| 설명 |
+| --- |
+| 음성채널은 Discord에서 사용자들이 실시간으로 음성을 통해 소통할 수 있는 공간입니다. 텍스트 채팅과 달리, 음성채널에서는 마이크를 사용하여 대화를 나눌 수 있으며, 동시에 여러 사람이 참여할 수 있습니다. |
+
+## 2. Discord 가입 및 설정
+
+음성채널에 참석하려면 먼저 Discord에 가입해야 합니다. 아래의 테이블은 가입 및 설정에 필요한 단계를 설명합니다:
+
+| 단계 | 설명 |
+| --- | --- |
+| **1. Discord 가입** | [Discord 웹사이트](https://discord.com/)에 접속하여 무료로 계정을 생성합니다. 이메일 주소를 입력하고 비밀번호를 설정하면 가입이 완료됩니다. |
+| **2. 앱 다운로드 (선택 사항)** | Discord는 웹브라우저에서도 사용할 수 있지만, 데스크탑 또는 모바일 앱을 다운로드하여 사용하는 것이 더 편리할 수 있습니다.
- [Windows/Mac 다운로드](https://discord.com/download)
- [iOS/Android 앱스토어](https://discord.com/download)에서 다운로드 |
+| **3. 서버 참여** | 서버 초대 링크를 통해 원하는 서버에 참여합니다. 초대 링크를 클릭하면 자동으로 서버에 가입됩니다. |
+
+## 3. 음성채널에 접속하기
+
+| 단계 | 설명 |
+| --- | --- |
+| **1. 채널 선택** | Discord 서버의 좌측 패널에서 원하는 음성채널을 클릭합니다. |
+| **2. 음성 연결** | 음성채널에 자동으로 연결되며, 마이크와 스피커를 통해 대화가 가능합니다. |
+| **3. 나가기** | 음성채널에서 나가려면 좌측 하단의 `전화 끊기` 아이콘을 클릭합니다. |
+
+
+
+
+
+## 4. 음성채널에서 할 수 있는 일
+
+음성채널에서 할 수 있는 주요 작업을 아래 테이블에서 설명합니다:
+
+| 작업 | 설명 |
+| --- | --- |
+| **마이크 음소거/해제** | 마이크 아이콘을 클릭하여 자신을 음소거하거나 음소거 해제할 수 있습니다. |
+| **사용자 볼륨 조절** | 채널 내 다른 사용자의 볼륨을 개별적으로 조정할 수 있습니다. |
+| **화면 공유** | 화면 아이콘을 클릭하여 자신의 화면을 공유할 수 있습니다.
- **화면 공유 시작**: 음성채널에 접속한 후, 하단의 `화면` 아이콘을 클릭합니다.
- **공유할 화면 선택**: 전체 화면 또는 특정 응용 프로그램 창을 선택하여 공유할 수 있습니다.
- **화면 공유 종료**: 화면 공유를 중지하려면 `화면 공유 중지` 버튼을 클릭합니다. |
+| **채팅으로 커뮤니케이션** | 음성채널에 있는 동안 텍스트 채팅을 통해서도 자유롭게 소통할 수 있습니다. |
+| **채널 간 이동** | 다른 음성채널로 손쉽게 이동할 수 있습니다. |
+
+
+## 5. 모각코란?
+
+모각코는 오후 10시 쯔음 사람들이 많이 모입니다.
+
+| 항목 | 설명 |
+| --- | --- |
+| **모각코 정의** | "모두 각자 코딩"의 약어로, Discord 음성채널에 모여 각자 공부하거나 코딩하는 활동을 말합니다. |
+| **모각코 참여 방법** | 음성채널에 접속하여 각자 공부나 코딩을 진행하면 됩니다. 혼자 공부하는 것보다 여러 사람과 함께 모여서 공부하면 더 집중할 수 있고, 동기부여가 될 수 있습니다. **모각코에 참여** 하려면 먼저 [디스코드 채널]([https://discord.gg/jUCqgExumm](https://discord.gg/MFgKD4NSAn)에 1회 가입 후, [모각코 음성 채널](https://discord.gg/4b4CFhd62C)에 입장해야 합니다. |
+| **화면 공유 선택** | 자신의 코딩 또는 공부 내용을 다른 사람들과 공유하고 싶다면, 화면 공유 기능을 사용할 수 있습니다. 하지만 화면 공유는 선택 사항이며, 강제는 아닙니다. |
+| **자유로운 소통** | 필요에 따라 텍스트 채팅이나 음성으로 다른 참여자와 소통할 수 있지만, 이 역시 자유롭게 선택할 수 있습니다. |
+| **목적** | 함께 모여서 각자 집중하는 시간을 가지는 것이 목적이므로, 부담 없이 참여할 수 있습니다. |
+
+**채널 입장 화면**
+
+
+
+**영상 공유 화면(필수 아님)**
+
+
+
+
+## 6. 문제 해결
+
+| 문제 | 해결 방법 |
+| --- | --- |
+| **마이크 작동 안 함** | 마이크 설정이 올바르게 되어 있는지 확인하고, Discord의 음성 설정에서 마이크 입력 장치를 확인하세요. |
+| **소리가 들리지 않음** | 스피커 또는 헤드폰 연결을 확인하고, Discord 음성 설정에서 출력 장치를 확인하세요. |
+| **지연/끊김 현상** | 인터넷 연결 상태를 확인하고, Discord 서버의 위치를 변경하여 해결할 수 있습니다. |
+| **권한 문제** | 서버 관리자에게 문의하여 적절한 권한을 부여받으세요. |
+
+---
+
+이 설명서가 Discord 음성채널과 모각코 활동에 도움이 되길 바랍니다. 궁금한 점이 있으면 언제든지 질문하세요!
diff --git a/question_guide.md b/question_guide.md
new file mode 100644
index 0000000..a6aaca1
--- /dev/null
+++ b/question_guide.md
@@ -0,0 +1,74 @@
+# 현업에서 질문을 잘 하는 것의 중요성
+
+질문은 단순한 정보의 교환을 넘어서, 현업에서의 팀워크와 개인의 성장, 그리고 전체적인 프로젝트의 진행에 큰 영향을 미치는 활동입니다. 특히, IT 및 개발 분야에서는 복잡한 문제 해결과 지속적인 학습이 필요하기 때문에, 질문의 효율성과 질이 중요합니다. 아래에서는 현업에서 질문을 잘 하는 것이 중요한 이유와 그에 따른 혜택에 대해 상세하게 살펴보겠습니다.
+
+## 1. **시간 절약**
+명확하고 구체적인 질문을 통해 원하는 답변을 빠르게 얻을 수 있습니다. 이는 개발 과정에서 발생하는 불필요한 지연을 최소화하고, 프로젝트의 전체 진행 속도를 높일 수 있습니다. 또한, 팀원들과의 의사소통 시간도 효율적으로 활용할 수 있게 됩니다. 이러한 시간 절약은 프로젝트의 마감 시간을 준수하는 데 큰 도움이 됩니다. 더 나아가, 팀 전체의 작업 효율성이 향상되며, 빠른 의사결정과 문제 해결이 가능해집니다.
+
+## 2. **효율적인 협업**
+질문을 통해 문제점이나 오해를 즉시 해결할 수 있습니다. 이는 팀원 간의 의사소통을 원활하게 하며, 협업의 효율성을 높입니다. 명확한 질문은 더 나은 협업을 위한 기반이 됩니다. 팀원 간의 미해결된 의문점이나 오해는 프로젝트의 진행을 방해할 수 있기 때문에, 이를 빠르게 해결하는 것이 중요합니다. 또한, 질문을 통해 팀원 간의 지식 공유와 서로의 견해를 이해하는 데 큰 도움이 됩니다.
+
+## 3. **지식의 확장**
+질문은 개인의 지식을 확장하는 데 중요한 도구입니다. 다양한 질문을 통해 새로운 지식을 습득하고, 기존의 지식을 깊게 이해할 수 있습니다. 이는 개인의 전문성을 높이는 데 큰 도움이 됩니다. 또한, 다른 팀원들의 지식과 경험도 공유받을 수 있어, 전체 팀의 역량 향상에 기여합니다. 지속적인 질문은 지식의 깊이를 높이며, 전문가로서의 경쟁력을 갖출 수 있게 합니다.
+
+## 4. **문제 해결 능력 향상**
+문제 상황을 정확하게 파악하고, 이에 대한 해결책을 요청하는 질문은 문제 해결 능력을 향상시킵니다. 이는 개발자로서의 전문성을 높이는 데 큰 도움이 됩니다. 문제를 해결하는 과정에서의 질문은 문제의 원인과 해결 방안을 더 깊게 이해하는 데 도움을 줍니다. 또한, 다양한 문제 상황에 대한 해결 경험을 축적하게 되어, 미래의 유사한 문제에 대처하는 능력도 향상됩니다.
+
+## 5. **팀의 문화 형성**
+질문을 적극적으로 활용하는 팀은 개방적이고 학습 지향적인 문화를 형성하는 경향이 있습니다. 이러한 문화는 팀의 지속적인 성장과 발전을 촉진합니다. 팀 내에서의 질문과 답변의 과정은 팀원 간의 신뢰와 유대를 강화하는 데도 기여합니다. 개방적인 질문 문화는 팀원 간의 의사소통을 촉진하며, 서로를 더 잘 이해하게 됩니다.
+
+## 6. **나에 대한 인식**
+질문의 방식과 내용은 팀원들에게 나의 전문성, 학습 의지, 그리고 협업에 대한 태도를 보여줍니다. 적절하고 명확한 질문은 나에 대한 긍정적인 인식을 형성하는 데 도움을 줍니다. 반대로, 부적절한 질문은 나에 대한 부정적인 인식을 낳을 수 있으므로, 질문의 방식과 내용에는 항상 주의를 기울여야 합니다. 특히, 전문 분야에서는 질문의 품질이 나의 전문성과 업무 태도를 반영하기 때문에, 이를 통해 팀원들과의 관계와 나에 대한 인식에 큰 영향을 미칠 수 있습니다.
+
+## 결론
+현업에서 질문을 잘 하는 것은 단순히 답을 얻기 위한 행위를 넘어서, 팀의 전체적인 성과와 개인의 전문성 향상, 그리고 나에 대한 인식 형성에까지 큰 영향을 미칩니다. 따라서, 질문의 중요성을 인식하고, 이를 통해 더 나은 협업과 성장을 추구해야 합니다.
+
+# 효과적인 질문 방법
+질문하는 것은 지식을 확장하고 문제를 해결하는 데 중요한 도구입니다. 그러나 모든 질문이 동일하게 효과적인 것은 아닙니다. 효과적인 질문을 통해 원하는 답변을 더 빠르고 정확하게 얻을 수 있습니다. 이 글에서는 어떻게 질문해야 원하는 답변을 효과적으로 받을 수 있는지에 대한 방법을 살펴보겠습니다.
+
+## 1. 명확하게 질문하기
+
+질문의 명확성은 답변의 정확성에 직접적인 영향을 미칩니다.
+- **구체적인 정보 제공**: 질문의 배경, 사용 중인 도구나 기술, 문제의 세부 사항 등 필요한 정보를 명확하게 제공하세요. 이 정보는 답변자가 문제의 맥락을 이해하는 데 도움이 됩니다.
+- **짧고 간결하게**: 너무 긴 질문은 읽는 데 시간이 걸리며, 중요한 정보가 묻힐 수 있습니다. 핵심만을 간결하게 전달하세요. 그러나 너무 짧은 질문은 필요한 정보가 누락될 수 있으므로, 적절한 길이와 세부 사항을 포함하는 것이 중요합니다.
+### 좋은 질문
+> "Python에서 리스트의 특정 항목을 어떻게 삭제할 수 있나요? 예를 들어, ['apple', 'banana', 'cherry']에서 'banana'를 삭제하고 싶습니다."
+### 좋지 않은 질문
+> "리스트에서 어떻게 항목을 삭제하죠?"
+## 2. 문제를 재현하기
+문제를 재현하는 것은 답변자가 문제를 이해하고 해결 방법을 제안하는 데 중요합니다.
+- **단계별로 설명**: 문제가 발생하는 상황을 단계별로 설명하면, 다른 사람이 문제를 이해하고 해결하는 데 도움이 됩니다. 가능한 한 구체적으로 문제 발생 상황을 설명하세요.
+- **에러 메시지 첨부**: 발생한 에러 메시지나 스크린샷을 첨부하면 문제의 원인을 파악하는 데 큰 도움이 됩니다. 에러 메시지는 문제의 원인을 직접적으로 알려주는 중요한 정보입니다.
+### 좋은 질문
+> "Python에서 배열을 정렬할 때 sort() 함수를 사용했는데, 숫자 배열이 제대로 정렬되지 않습니다. 예: [10, 2, 15].sort() 결과는 [10, 15, 2]입니다. 왜 이런 결과가 나오는지 설명해 주실 수 있나요?"
+### 좋지 않은 질문
+> "왜 배열이 제대로 정렬되지 않죠?"
+## 3. 질문의 목적 명시하기
+질문의 목적을 명확히 하면, 답변자가 원하는 방향으로 답변을 제공하는 데 도움이 됩니다.
+- **원하는 결과 설명**: 단순히 문제를 설명하는 것뿐만 아니라, 원하는 결과나 목표를 명확하게 설명하세요. 이를 통해 답변자는 더 적절한 해결책을 제안할 수 있습니다.
+- **기대하는 답변 유형 명시**: 예를 들어, 코드 수정 방법, 관련 자료나 링크, 전략적인 조언 등 원하는 답변의 유형을 명시하세요. 이렇게 함으로써 답변자는 특정 방향으로 답변을 준비할 수 있습니다.
+### 좋은 질문
+> "파이썬과 와 C++ 중 어떤 것을 선택하는 것이 좋을까요? 주로 대규모 프로젝트에 사용하려고 합니다."
+### 좋지 않은 질문
+> "파이썬과 C++ 중 뭐가 좋아요?"
+## 4. 예의를 갖추고 인내심 갖기
+질문의 방식과 태도는 답변의 품질과 속도에 큰 영향을 미칩니다.
+- **친절하게 요청**: 질문자의 태도는 답변자의 반응에 큰 영향을 미칩니다. 친절하게 요청하고 감사의 말을 빠뜨리지 마세요. 상대방도 자신의 시간과 노력을 들여 답변을 제공하므로, 그 노력에 대한 감사의 표현은 필수입니다.
+- **인내심 갖기**: 모든 질문에 즉시 답변이 오는 것은 아닙니다. 조금의 인내심을 갖고 기다리세요. 또한, 답변이 오지 않는 경우에도 불편함을 표현하기보다는 추가적인 정보를 제공하거나 질문을 다르게 접근하는 것이 도움이 될 수 있습니다.
+### 좋은 질문
+> "죄송합니다, 이 부분에 대해 이해가 잘 되지 않아서 추가적인 설명을 부탁드려도 될까요?"
+### 좋지 않은 질문
+> "왜 답변이 이렇게 늦죠?"
+## 5. 받은 답변에 대한 피드백 제공
+답변을 받은 후의 피드백은 질문과 답변의 상호작용을 더욱 풍부하게 만듭니다.
+- **해결 여부 알리기**: 제공된 답변이 문제를 해결했는지, 또는 추가적인 정보가 필요한지 알려주세요. 이 정보는 답변자에게 그들의 답변이 얼마나 효과적인지를 알려줍니다.
+- **감사의 말 전하기**: 답변자의 노력에 감사의 말을 전하세요. 이것은 답변자에게 그들의 노력이 가치 있었다는 것을 알려주는 좋은 방법입니다.
+### 좋은 피드백
+> "정말 감사합니다! 답변 덕분에 문제를 해결할 수 있었습니다."
+### 좋지 않은 피드백
+> "이미 알고 있는 정보입니다."
+
+이러한 사례를 통해 우리는 질문의 방식이 답변의 품질과 속도에 어떠한 영향을 미치는지 알 수 있습니다. 따라서, 질문을 할 때는 상대방의 입장에서 생각하며, 명확하고 구체적인 정보를 제공하는 것이 중요합니다.
+효과적인 질문은 단순히 답을 얻기 위한 수단이 아닙니다. 그것은 상호 존중과 학습의 과정을 통해 지식을 확장하고, 문제 해결 능력을 향상시키는 방법입니다. 따라서, 질문의 방법과 태도에 조금 더 신경 쓰면, 원하는 답변을 더욱 효과적으로 얻을 수 있습니다.
+
+
diff --git a/reference/topologicalsort.py b/reference/topologicalsort.py
index 7fd1c66..870828c 100644
--- a/reference/topologicalsort.py
+++ b/reference/topologicalsort.py
@@ -18,7 +18,7 @@
# 예시 그래프 도식화:
# 각 노드 옆 괄호 안에는 해당 노드의 진입 차수를 표기하였습니다.
#
-# 0(0) --> 1(1) --> 3(2)
+# 0(0) --> 1(1) --> 3(1)
# | | |
# v v v
# 2(1) --> 4(2) --> 5(2)
@@ -30,7 +30,7 @@
# 큐: []
# 1. 진입 차수 계산
-# 진입 차수: 0(0), 1(1), 2(1), 3(1), 4(1), 5(2)
+# 진입 차수: 0(0), 1(1), 2(1), 3(1), 4(2), 5(2)
# 2. 진입 차수가 0인 노드(0)를 큐에 추가
# 결과 리스트: []
@@ -41,7 +41,7 @@
# 큐: []
# 4. 현재 노드 0 처리
-# 진입 차수: 0(0), 1(0), 2(1), 3(1), 4(1), 5(2)
+# 진입 차수: 0(0), 1(0), 2(0), 3(1), 4(2), 5(2)
# 큐: []
# 5. 진입 차수가 0인 노드(1)를 큐에 추가
@@ -53,47 +53,59 @@
# 큐: []
# 7. 현재 노드 1 처리
-# 진입 차수: 0(0), 1(0), 2(1), 3(0), 4(1), 5(2)
+# 진입 차수: 0(0), 1(0), 2(0), 3(0), 4(1), 5(2)
# 큐: []
-# 8. 진입 차수가 0인 노드(3)를 큐에 추가
+# 8. 진입 차수가 0인 노드(2)를 큐에 추가
# 결과 리스트: [0, 1]
-# 큐: [3]
+# 큐: [2]
# 9. 큐에서 노드를 꺼내 결과 리스트에 추가
-# 결과 리스트: [0, 1, 3]
+# 결과 리스트: [0, 1, 2]
# 큐: []
-# 10. 현재 노드 3 처리
-# 진입 차수: 0(0), 1(0), 2(1), 3(0), 4(1), 5(1)
+# 10. 현재 노드 2 처리
+# 진입 차수: 0(0), 1(0), 2(0), 3(0), 4(0), 5(2)
# 큐: []
-# 11. 진입 차수가 0인 노드(4)를 큐에 추가
-# 결과 리스트: [0, 1, 3]
-# 큐: [4]
+# 11. 진입 차수가 0인 노드(3)를 큐에 추가
+# 결과 리스트: [0, 1, 2]
+# 큐: [3]
# 12. 큐에서 노드를 꺼내 결과 리스트에 추가
-# 결과 리스트: [0, 1, 3, 4]
+# 결과 리스트: [0, 1, 2, 3]
# 큐: []
-# 13. 현재 노드 4 처리
-# 진입 차수: 0(0), 1(0), 2(0), 3(0), 4(0), 5(1)
+# 13. 현재 노드 3 처리
+# 진입 차수: 0(0), 1(0), 2(1), 3(0), 4(0), 5(1)
# 큐: []
-# 14. 진입 차수가 0인 노드(5)를 큐에 추가
-# 결과 리스트: [0, 1, 3, 4]
-# 큐: [5]
+# 14. 진입 차수가 0인 노드(4)를 큐에 추가
+# 결과 리스트: [0, 1, 2, 3]
+# 큐: [4]
# 15. 큐에서 노드를 꺼내 결과 리스트에 추가
-# 결과 리스트: [0, 1, 3, 4, 5]
+# 결과 리스트: [0, 1, 2, 3, 4]
+# 큐: []
+
+# 16. 현재 노드 4 처리
+# 진입 차수: 0(0), 1(0), 2(0), 3(0), 4(0), 5(0)
+# 큐: []
+
+# 17. 진입 차수가 0인 노드(5)를 큐에 추가
+# 결과 리스트: [0, 1, 2, 3, 4]
+# 큐: [5]
+
+# 18. 큐에서 노드를 꺼내 결과 리스트에 추가
+# 결과 리스트: [0, 1, 2, 3, 4, 5]
# 큐: []
-# 16. 현재 노드 5 처리
+# 19. 현재 노드 5 처리
# 진입 차수: 0(0), 1(0), 2(0), 3(0), 4(0), 5(0)
# 큐: []
-# 17. 위상 정렬 완료
-# 결과 리스트: [0, 1, 3, 4, 5]
+# 20. 위상 정렬 완료
+# 결과 리스트: [0, 1, 2, 3, 4, 5]
# 큐: []
from collections import deque
diff --git a/solution/01.py b/solution/01.py
index 6a9505f..fb9c69b 100644
--- a/solution/01.py
+++ b/solution/01.py
@@ -1,3 +1,9 @@
def solution(arr):
- arr.reverse( )
+ arr.sort()
return arr
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([1,-5,2,4,3])) # 반환값 : [-5, 1, 2, 3, 4]
+# print(solution([2,1,1,3,2,5,4])) # 반환값 : [1, 1, 2, 2, 3, 4, 5]
+# print(solution([1,6,7])) # 반환값 : [1, 6, 7]
diff --git a/solution/02.py b/solution/02.py
index 8e5e33b..38eecb2 100644
--- a/solution/02.py
+++ b/solution/02.py
@@ -2,3 +2,7 @@ def solution(lst):
unique_lst = list(set(lst)) # ➊ 중복값 제거
unique_lst.sort(reverse=True) # ➋ 내림차순 정렬
return unique_lst
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([4, 2, 2, 1, 3, 4])) # 반환값 : [4, 3, 2, 1]
+# print(solution([2, 1, 1, 3, 2, 5, 4])) # 반환값 : [5, 4, 3, 2, 1]
diff --git a/solution/03.py b/solution/03.py
index cb2c210..6ec923b 100644
--- a/solution/03.py
+++ b/solution/03.py
@@ -8,3 +8,7 @@ def solution(numbers):
# ➍ 중복된 값을 제거하고, 오름차순으로 정렬
ret = sorted(set(ret))
return ret # ➎ 최종 결과 반환
+
+#TEST 코드입니다. 주석을 풀어서 확인해보세요
+# print(solution([2, 1, 3, 4, 1])) # 반환값 : [2, 3, 4, 5, 6, 7]
+# print(solution([5, 0, 2, 7])) # 반환값 : [2, 5, 7, 9, 12]
diff --git a/solution/08.py b/solution/08.py
index 171d96f..4e13552 100644
--- a/solution/08.py
+++ b/solution/08.py
@@ -12,3 +12,8 @@ def solution(s):
return False
else:
return True
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+#print(solution('(())()')) # 반환값 : True
+#print(solution('((())()')) # 반환값 : False
diff --git a/solution/09.py b/solution/09.py
index 7dd2a76..f3f606c 100644
--- a/solution/09.py
+++ b/solution/09.py
@@ -6,3 +6,9 @@ def solution(decimal):
decimal //= 2
stack.reverse()
return ''.join(stack)
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution(10)) #반환값 : 1010
+# print(solution(27)) #반환값 : 11011
+# print(solution(12345)) #반환값 : 11000000111001
diff --git a/solution/15.py b/solution/15.py
index 20c1244..271bc6b 100644
--- a/solution/15.py
+++ b/solution/15.py
@@ -7,8 +7,8 @@ def solution(N, K):
while len(queue) > 1: #❷ deque에 하나의 요소가 남을 때까지
for _ in range(K-1):
queue.append(queue.popleft()) #❸ K번째 요소를 찾기 위해 앞에서부터 제거하고 뒤에 추가
- queue.popleft() #❹ K번째 요소 제거
+ queue.popleft() #❹ K번째 요소 제거
return queue[0] #❺ 마지막으로 남은 요소 반환
-
-
-print(solution(5,2))
\ No newline at end of file
+
+
+print(solution(5,2))
diff --git a/solution/18.py b/solution/18.py
index 141591e..2ddb80a 100644
--- a/solution/18.py
+++ b/solution/18.py
@@ -23,3 +23,7 @@ def solution(arr, target):
):
return True
return False
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([1, 2, 3, 4, 8], 6)) # 반환값 : True
+# print(solution([2, 3, 5, 9], 10)) # 반환값 : False
diff --git a/solution/19.py b/solution/19.py
index ddaac7f..2a8414f 100644
--- a/solution/19.py
+++ b/solution/19.py
@@ -6,6 +6,7 @@ def polynomial_hash(str):
for char in str:
hash_value = (hash_value * p + ord(char)) % m
return hash_value
+
def solution(string_list, query_list):
# ➋ string_list의 각 문자열에 대해 다항 해시값을 계산
hash_list = [polynomial_hash(str) for str in string_list]
@@ -19,3 +20,6 @@ def solution(string_list, query_list):
else:
result.append(False)
return result
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution(["apple", "banana", "cherry"], ["banana", "kiwi", "melon", "apple"] )) # 반환값 : [True, False, False, True]
diff --git a/solution/26.py b/solution/26.py
index 835d9b1..e808dbb 100644
--- a/solution/26.py
+++ b/solution/26.py
@@ -44,3 +44,7 @@ def solution(nodes):
inorder(nodes,0)[:-1], # 마지막 공백 제거
postorder(nodes,0)[:-1], # 마지막 공백 제거
]
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([1, 2, 3, 4, 5, 6, 7])) # 반환값 : ["1 2 4 5 3 6 7", "4 2 5 1 6 3 7", "4 5 2 6 7 3 1"]
diff --git a/solution/27.py b/solution/27.py
index 7d206b2..ec283f1 100644
--- a/solution/27.py
+++ b/solution/27.py
@@ -61,3 +61,8 @@ def solution(lst, search_lst):
else:
result.append(False)
return result
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([5, 3, 8, 4, 2, 1, 7, 10], [1, 2, 5, 6])) # [True, True, True, False]
+# print(solution([1, 3, 5, 7, 9], [2, 4, 6, 8, 10])) # [False, False, False, False, False]
diff --git a/solution/33.py b/solution/33.py
index 2f64da0..25c9b3d 100644
--- a/solution/33.py
+++ b/solution/33.py
@@ -30,6 +30,7 @@ def solution(k, operations):
return n # 집합의 개수를 반환
-
-print(solution(3,[['u', 0, 1], ['u', 1, 2], ['f', 2]]))
-print(solution(4,[['u', 0, 1], ['u', 2, 3], ['f', 0]]))
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution(3,[['u', 0, 1], ['u', 1, 2], ['f', 2]])) # 반환값 : 1
+# print(solution(4,[['u', 0, 1], ['u', 2, 3], ['f', 0]])) # 반환값 : 2
diff --git a/solution/38.py b/solution/38.py
index 4b87d4f..83e8284 100644
--- a/solution/38.py
+++ b/solution/38.py
@@ -19,3 +19,7 @@ def dfs(node, visited, result):
result = []
dfs(start, visited, result) # ❼ 시작 노드에서 깊이 우선 탐색 시작
return result # ❽ DFS 탐색 결과 반환
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([['A', 'B'], ['B', 'C'], ['C', 'D'], ['D', 'E']], 'A')) # 반환값 : ['A', 'B', 'C', 'D', 'E']
+# print(solution([['A', 'B'], ['A', 'C'], ['B', 'D'], ['B', 'E'], ['C', 'F'], ['E', 'F']], 'A')) # 반환값 : ['A', 'B', 'D', 'E', 'F', 'C']
diff --git a/solution/39.py b/solution/39.py
index b2dad99..ff61f3f 100644
--- a/solution/39.py
+++ b/solution/39.py
@@ -29,7 +29,7 @@ def bfs(start):
bfs(start) # ❽ 시작 노드부터 BFS 탐색 수행
return result
-#결과값 확인
-#print(solution([(1, 2), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7), (4, 8), (5, 8), (6, 9), (7, 9)],1))
-#print(solution([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 0)],1))
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([(1, 2), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7), (4, 8), (5, 8), (6, 9), (7, 9)],1)) # 반환값 :[1, 2, 3, 4, 5, 6, 7, 8, 9]
+# print(solution([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 0)],1)) # 반환값 : [1, 2, 3, 4, 5, 0]
diff --git a/solution/40-2.py b/solution/40-2.py
new file mode 100644
index 0000000..ef36836
--- /dev/null
+++ b/solution/40-2.py
@@ -0,0 +1,30 @@
+import heapq
+
+def solution(graph, start):
+ distances = {node: float("inf") for node in graph} # 모든 노드의 거리 값을 무한대로 초기화
+ distances[start] = 0 # 시작 노드의 거리 값은 0으로 초기화
+ queue = []
+ heapq.heappush(queue, [distances[start], start]) # 시작 노드를 큐에 삽입
+ paths = {start: [start]} # 시작 노드의 경로를 초기화
+ visited = set() # 방문한 노드를 저장할 집합
+
+ while queue:
+ current_distance, current_node = heapq.heappop(queue)
+ if current_node in visited: # 이미 방문한 노드는 무시
+ continue
+ visited.add(current_node) # 현재 노드를 방문한 노드 집합에 추가
+
+ for adjacent_node, weight in graph[current_node].items():
+ distance = current_distance + weight
+ if distance < distances[adjacent_node]:
+ distances[adjacent_node] = distance
+ paths[adjacent_node] = paths[current_node] + [adjacent_node]
+ heapq.heappush(queue, [distance, adjacent_node])
+
+ sorted_paths = {node: paths[node] for node in sorted(paths)}
+
+ return [distances, sorted_paths]
+
+# TEST 코드
+print(solution({ 'A': {'B': 9, 'C': 3}, 'B': {'A': 5}, 'C': {'B': 1} }, 'A'))
+print(solution({'A': {'B': 1}, 'B': {'C': 5}, 'C': {'D': 1}, 'D': {}}, 'A'))
diff --git a/solution/40.py b/solution/40.py
index 00815e1..bd23daf 100644
--- a/solution/40.py
+++ b/solution/40.py
@@ -29,3 +29,9 @@ def solution(graph, start):
sorted_paths = {node: paths[node] for node in sorted(paths)}
return [distances, sorted_paths]
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution({ 'A': {'B': 9, 'C': 3}, 'B': {'A': 5}, 'C': {'B': 1} },'A')) # 반환값 :[{'A': 0, 'B': 4, 'C': 3}, {'A': ['A'], 'B': ['A', 'C', 'B'], 'C': ['A', 'C']}]
+# print(solution({'A': {'B': 1},'B': {'C': 5},'C': {'D': 1},'D': { } }, 'A')) # 반환값 :[{'A': 0, 'B': 1, 'C': 6, 'D': 7}, {'A': ['A'], 'B': ['A', 'B'], 'C': ['A', 'B', 'C'], 'D': ['A', 'B', 'C', 'D']}]
+
diff --git a/solution/41.py b/solution/41.py
index 37f5a86..333df9f 100644
--- a/solution/41.py
+++ b/solution/41.py
@@ -28,3 +28,7 @@ def solution(graph, source):
# ❿ 음의 가중치 순회가 발견되었으므로 [-1]을 반환합니다.
return [-1]
return [distance, predecessor]
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([[(1, 4), (2, 3), (4, -6 )], [(3, 5)], [(1, 2)], [(0, 7), (2, 4)],[(2, 2)]],0)) #반환갑 : [[0, -2, -4, 3, -6], [None, 2, 4, 1, 0]]
+# print(solution([[(1, 5), (2, -1)], [(2, 2)], [(3, -2)], [(0, 2), (1, 6)]],0)) # 반환값 : [-1]
diff --git a/solution/47.py b/solution/47.py
index 571ac2f..9ebfc91 100644
--- a/solution/47.py
+++ b/solution/47.py
@@ -14,3 +14,9 @@ def backtrack(sum, selected_nums, start):
backtrack(0, [], 1) # ❻ 백트래킹 함수 호출
return results # ❼ 조합 결과 반환
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution(5)) # 반환값 : [[1, 2, 3, 4], [1, 4, 5], [2, 3, 5]]
+# print(solution(2)) # 반환값 : []
+# print(solution(7)) # 반환값 : [[1, 2, 3, 4], [1, 2, 7], [1, 3, 6], [1, 4, 5], [2, 3, 5], [3, 7], [4, 6]]
diff --git a/solution/48.py b/solution/48.py
index 1a2b5cd..c5036d6 100644
--- a/solution/48.py
+++ b/solution/48.py
@@ -46,3 +46,74 @@ def find_solution():
find_solution()
return board
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+'''
+print(solution(
+[
+ [5, 3, 0, 0, 7, 0, 0, 0, 0],
+ [6, 0, 0, 1, 9, 5, 0, 0, 0],
+ [0, 9, 8, 0, 0, 0, 0, 6, 0],
+ [8, 0, 0, 0, 6, 0, 0, 0, 3],
+ [4, 0, 0, 8, 0, 3, 0, 0, 1],
+ [7, 0, 0, 0, 2, 0, 0, 0, 6],
+ [0, 6, 0, 0, 0, 0, 2, 8, 0],
+ [0, 0, 0, 4, 1, 9, 0, 0, 5],
+ [0, 0, 0, 0, 8, 0, 0, 7, 9],
+])
+)
+'''
+
+'''
+반환값 :
+[
+[5, 3, 4, 6, 7, 8, 9, 1, 2],
+[6, 7, 2, 1, 9, 5, 3, 4, 8],
+[1, 9, 8, 3, 4, 2, 5, 6, 7],
+[8, 5, 9, 7, 6, 1, 4, 2, 3],
+[4, 2, 6, 8, 5, 3, 7, 9, 1],
+[7, 1, 3, 9, 2, 4, 8, 5, 6],
+[9, 6, 1, 5, 3, 7, 2, 8, 4],
+[2, 8, 7, 4, 1, 9, 6, 3, 5],
+[3, 4, 5, 2, 8, 6, 1, 7, 9],
+]
+'''
+
+
+'''
+print(solution(
+[
+[0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0],
+])
+)
+'''
+
+
+'''
+반환값 :
+[
+[1, 2, 3, 4, 5, 6, 7, 8, 9],
+[4, 5, 6, 7, 8, 9, 1, 2, 3],
+[7, 8, 9, 1, 2, 3, 4, 5, 6],
+[2, 3, 4, 5, 6, 7, 8, 9, 1],
+[5, 6, 7, 8, 9, 1, 2, 3, 4],
+[8, 9, 1, 2, 3, 4, 5, 6, 7],
+[3, 4, 5, 6, 7, 8, 9, 1, 2],
+[6, 7, 8, 9, 1, 2, 3, 4, 5],
+[9, 1, 2, 3, 4, 5, 6, 7, 8],
+]
+'''
+
+
+
+
+
diff --git a/solution/54.py b/solution/54.py
index 780e0de..a07fc26 100644
--- a/solution/54.py
+++ b/solution/54.py
@@ -11,3 +11,8 @@ def solution(s):
sorted_str += chr(i + ord("a")) * counts[i]
return sorted_str
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+print(solution('hello')) # 반환값 : 'ehllo'
+print(solution('algorithm')) # 반환값 : 'aghilmort'
diff --git a/solution/55.py b/solution/55.py
index dfe0f1b..715506e 100644
--- a/solution/55.py
+++ b/solution/55.py
@@ -20,3 +20,8 @@ def solution(arr1, arr2):
j += 1
return merged
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([1, 3, 5], [2, 4, 6])) # 반환값 : [1, 2, 3, 4, 5, 6]
+# print(solution([1, 2, 3], [4, 5, 6])) # 반환값 : [1, 2, 3, 4, 5, 6]
diff --git a/solution/62.py b/solution/62.py
index 018fd1b..9372344 100644
--- a/solution/62.py
+++ b/solution/62.py
@@ -23,3 +23,44 @@ def rotate_90(arr):
rotated_arr = rotate_90(rotated_arr)
return rotated_arr
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+'''
+print(solution(
+[
+ [1, 2, 3, 4],
+ [5, 6, 7, 8],
+ [9, 10, 11, 12],
+ [13, 14, 15, 16]
+], 1))
+'''
+
+'''
+반환값 :
+[
+[13, 9, 5, 1],
+[14, 10, 6, 2],
+[15, 11, 7, 3],
+[16, 12, 8, 4]
+]
+'''
+
+'''
+print(solution(
+[
+ [1, 2, 3, 4],
+ [5, 6, 7, 8],
+ [9, 10, 11, 12],
+ [13, 14,15,16]
+ ], 2))
+'''
+
+'''
+반환값 :
+[
+[16, 15, 14, 13],
+[12, 11, 10, 9],
+[8, 7, 6, 5],
+[4, 3, 2, 1]
+]
+'''
diff --git a/solution/63.py b/solution/63.py
index ea8f2f5..693fdef 100644
--- a/solution/63.py
+++ b/solution/63.py
@@ -28,3 +28,52 @@ def solution(matrix1, matrix2):
# 곱셈 결과의 전치 행렬을 계산합니다.
transposed = transpose_matrix(multiplied)
return transposed
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+'''
+print(solution(
+[
+ [1, 2, 3],
+ [4, 5, 6],
+ [7, 8, 9]
+],
+
+[
+ [9, 8, 7],
+ [6, 5, 4],
+ [3, 2, 1]
+]))
+'''
+
+'''
+반환값 :
+[
+ [30, 84, 138],
+ [24, 69, 114],
+ [18, 54, 90]
+]
+'''
+
+'''
+print(solution(
+[
+ [2, 4, 6],
+ [1, 3, 5],
+ [7, 8, 9]
+],
+
+[
+ [9, 1, 2],
+ [4, 5, 6],
+ [7, 3, 8]
+]))
+'''
+
+'''
+반환값 :
+[
+ [76, 56, 158],
+ [40, 31, 74],
+ [76, 60, 134]
+]
+'''
diff --git a/solution/64.py b/solution/64.py
index 11cba37..40a903b 100644
--- a/solution/64.py
+++ b/solution/64.py
@@ -36,3 +36,28 @@ def solution(n):
start_col += 1
return snail_array
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution(3))
+
+'''
+반환값 :
+[
+ [1, 2, 3],
+ [8, 9, 4],
+ [7, 6, 5]
+]
+'''
+
+# print(solution(4))
+
+'''
+반환값 :
+[
+ [1, 2, 3, 4],
+ [12, 13, 14, 5],
+ [11, 16, 15, 6],
+ [10, 9, 8, 7]
+]
+'''
diff --git a/solution/70.py b/solution/70.py
index 9868b13..fffa2b5 100644
--- a/solution/70.py
+++ b/solution/70.py
@@ -18,3 +18,7 @@ def solution(str1, str2):
# ❻ LCS 길이 반환
return dp[m][n]
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution("ABCBDAB","BDCAB")) # 반환값 : 4
+# print(solution("AGGTAB","GXTXAYB")) # 반환값 : 4
diff --git a/solution/71.py b/solution/71.py
index 7bd36b9..b30db21 100644
--- a/solution/71.py
+++ b/solution/71.py
@@ -1,4 +1,6 @@
-def lis(nums):
+# 답안 코드는 lis라고 되어있는데, 다른 문제와 통일하기 위해 lis로 구현했습니다. lis로 구현하신 경우 Test 코드에서도 lis로 이름을 바꿔주셔야 실행 됩니다.
+
+def solution(nums):
n = len(nums)
# ❶ dp[i]는 nums[i]를 마지막으로 하는 LIS의 길이를 저장하는 배열입니다.
@@ -14,3 +16,7 @@ def lis(nums):
# ❹ dp 배열에서 최댓값을 찾아 최장 증가 부분 수열의 길이를 반환합니다.
return max(dp)
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([1, 4, 2, 3, 1, 5, 7, 3])) # 반환값 : 5
+# print(solution([3, 2, 1])) # 반환값 : 1
diff --git a/solution/72.py b/solution/72.py
index db986a7..270ba9c 100644
--- a/solution/72.py
+++ b/solution/72.py
@@ -22,3 +22,8 @@ def solution(arr):
# ❺ 마지막 열에서 선택 가능한 4가지 조약돌 배치 패턴 중 최대 가중치를 반환합니다.
return max(dp[0][-1], dp[1][-1], dp[2][-1], dp[3][-1])
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([[1, 3, 3, 2], [2, 1, 4, 1], [1, 5, 2, 3]])) # 반환값 : 19
+# print(solution([[1, 7, 13, 2, 6], [2, -4, 2, 5, 4], [5, 3, 5, -3, 1]])) # 반환값 : 32
diff --git a/solution/80.py b/solution/80.py
index 00dd704..d314a77 100644
--- a/solution/80.py
+++ b/solution/80.py
@@ -10,3 +10,8 @@ def solution(amount):
amount -= coin # ❺ 정산이 완료된 거스름돈 뺌
# ❻ 거스름돈 리스트 반환
return change
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution(123)) # 반환값 : [100, 10, 10, 1, 1, 1]
+# print(solution(350)) # 반환값 : [100, 100, 100, 50]
diff --git a/solution/81.py b/solution/81.py
index 894a3d6..531ed72 100644
--- a/solution/81.py
+++ b/solution/81.py
@@ -33,3 +33,10 @@ def solution(items, weight_limit):
# ❾ 배낭의 무게 한도 내에서 담을 수 있는 물건들의 최대 가치를 반환
return knapsack(items, weight_limit)
+
+
+
+
+# TEST 코드 입니다. 주석을 풀고 실행시켜보세요
+# print(solution([[10, 19], [7, 10], [6, 10]], 15)) # 반환값 : 273.33
+# print(solution([[10, 60], [20, 100], [30, 120]], 50)) # 반환값 : 240
diff --git a/solution/README.md b/solution/README.md
index 8e8bb8f..194e18e 100644
--- a/solution/README.md
+++ b/solution/README.md
@@ -1,4 +1,11 @@
+## 커뮤니티
+| 제목 | 링크 |
+|------|------|
+|링크드인|[링크](https://www.linkedin.com/in/ultrasuperrok/)|
+|오픈톡방|[링크](https://open.kakao.com/o/gX0WnTCf)|
+|스터디 그룹|[링크](https://www.linkedin.com/groups/14606078/)|
+
## 05장 배열
| 파일명 | 문제 |난이도| 비고 |
diff --git a/study_guide.md b/study_guide.md
new file mode 100644
index 0000000..bf0023d
--- /dev/null
+++ b/study_guide.md
@@ -0,0 +1,34 @@
+# 스터디 생성/참여 안내
+
+스터디를 시작하고 싶지만 사람을 어떻게 모아야 할지 걱정되시나요? 걱정 마세요! 스터디를 개설하면 자동 노출 됩니다.
+
+## 스터디 그룹 가입하기
+[스터디그룹링크](https://www.linkedin.com/groups/14606078/)
+
+## 스터디 홍보 채널
+- [카카오 오픈채팅방 (820명 개발자 참여)](https://open.kakao.com/o/gX0WnTCf)
+- [디스코드 (620명)](https://discord.gg/jUCqgExumm)
+- [네이버 카페 (1200명)](https://cafe.naver.com/dremdeveloper)
+
+## 네이버 카페 질문 게시판
+- [질문 게시판 바로가기](https://cafe.naver.com/dremdeveloper) : 질문을 올려주시면 직접 답변을 드립니다.
+
+## 스터디 추천 주제
+- 프로그래머스 / 백준 스터디
+- 취업/면접 준비 스터디
+- 공부 인증
+- 코딩 테스트 합격자 되기 시리즈 1독 스터디
+
+## 자료 및 링크
+- [코딩 테스트 합격자 되기 - 무료 강의](https://inf.run/H9yxm)
+- [디스코드 가이드](https://github.com/dremdeveloper/codingtest_python/blob/main/discord.md)
+- [프로그래머스 정답코드 & 코테 필수 예제 (파이썬)](https://github.com/dremdeveloper/codingtest_python)
+- [프로그래머스 정답코드 & 코테 필수 예제 (C++)](https://github.com/dremdeveloper/codingtest_cpp)
+- [코딩 테스트 무료 손노트](https://cafe.naver.com/dremdeveloper/1107)
+- [기존 코딩 테스트 합격자 되기 스터디 내용 (각 쓰레드 참조)](https://discord.gg/KwYMvQWH5T)
+
+## 도움이 필요하신가요?
+- **이메일**: ultrasuperrok@gmail.com
+- **링크드인**: [링크](https://www.linkedin.com/in/ultrasuperrok)
+
+스터디 생성을 두려워하지 마세요. 당신도 할 수 있습니다!
diff --git "a/\354\240\225\354\230\244\355\221\234.md" "b/\354\240\225\354\230\244\355\221\234.md"
new file mode 100644
index 0000000..8c7edc7
--- /dev/null
+++ "b/\354\240\225\354\230\244\355\221\234.md"
@@ -0,0 +1,79 @@
+# 코딩테스트 합격자 되기 - 파이썬편 정오표
+
+이 문서는 코딩테스트 합격자 되기-파이썬 편의 정오표입니다. 독자 여러분의 정확한 이해를 돕기 위해 오류를 정정하고 업데이트합니다. 발견된 오류에 대한 정정 사항이나 추가 설명을 아래에 기록합니다.
+
+## 정오표 업데이트 정보
+
+- **최종 업데이트**: 2024-06-13
+- **문의 및 제보**: ultrasuperrok@gmail.com으로 제보해 주시거나 깃헙에 issue로 올려주시면 감사하겠습니다.
+
+## 정오표 내용
+
+| 페이지 | 잘못된 내용 | 정정된 내용 | 비고 |
+|--------|-------------|-------------|------|
+| 56 | 함수의 최고 차항을 남기고 차수를 지워 |함수의 최고 차항을 남기고 계수를 지워 | |
+| 59 | 최고차항만 남기고 차수를 지울까?
앞의 차수가 1이므로 제거할 것이 없음 | 최고차항만 남기고 계수를 지울까
앞의 계수가 1이므로 제거할 것이 없음 | |
+| 65 | 최고차항을 남기고 차수를 제거 | 최고차항을 남기고 계수를 제거 | |
+| 102 | 문제 01번 QR코드 부분 | QR코드가 보이도록 수정해야 함 | |
+| 64 | | | |
+| 75 | 인덱스 0 이상 2 미만의 원소를 슬라이싱하여 4를 출력합니다. | 인덱스 0 이상 2 미만의 원소를 슬라이싱하여 [1,2]를 출력합니다. | |
+| 23 | <목차> 94번 뉴스 클러스터링 | <목차> 94번 거리두기 확인하기 | |
+| 119 | 값은 challengers[i]이며 | 값은 challenger[i] / total이며 | |
+| 120 | 키는 각 사용자를 가리키는 숫자 | 키는 각 스테이지를 가리키는 숫자 | |
+| 102 | [-5, 1, 2 , 4, 3] | [-5, 1, 2 , 3, 4] | |
+| 104 | O(NlogN) 시간 복잡도의 sort() 함수를
4초가 걸렸지만 sort() 함수를
압도적으로 sort() 함수가 | O(NlogN) 시간 복잡도의 sort() 메서드를
4초가 걸렸지만 sort() 메서드를
압도적으로 sort() 메서드가 | |
+| 109 | 모든 조합을 확인하는 과정에서 중복을 체크하는 데 O(N2)이 걸립니다. 그리고 이를 정렬하는 데 O(N2log(N2))이 걸리므로 최종 시간 복잡도는 O(N2log(N2))입니다. | 2중 반복문을 통해 모든 원소들에 대해 두 수의 합을 구하는 연산의 시간복잡도는 O(N^2) 입니다.이 후, 이를 Set으로 만들때 시간복잡도는 O(N^2)입니다. N^2개의 데이터를 정렬하는데는 O(N^2log(N^2))이 됩니다. 따라서 최종적으로 시간복잡도는 O(N^2log(N^2))이 됩니다. | |
+| 375 | 인접리스트의 공간복잡도가 O(N^2)으로 되어있습니다. | - 인접리스트의 공간복잡도는 O(N+M)로 수정되야 합니다.(M은 간선의 갯수 입니다.) | |
+| 126 | | | |
+| 183 | 표에 pop() 연산 설명이 반대로 되어 있습니다 | 큐에서 처음에 푸시한 데이터를 팝하고 | |
+| 183 | 그림에 pop() 연산이 2개입니다 | (위쪽 pop( )을 push( )로) | |
+| 192 | 선형 큐를 이용해 이 문제를 푸는 과정을 정리 하면 다음과 같습니다. |선형 큐를 이용해 이 문제를 푸는 과정을 정리 하면 다음과 같습니다. 다음에 "아래는 N이 5이고 k가 3인 경우 입니다." 추가 | |
+| 194 | queue.popleft() # ❹ K번째 요소 제거 의 들여쓰기가 하나 더들어감 | queue.popleft() # ❹ K번째 요소 제거 의 들여쓰기 하나제거(github 코드 참조)https://github.com/dremdeveloper/codingtest_python/blob/main/solution/15.py | |
+| 232~233 | paritipant_hash(몇개 있음) | 모두 participant_hash로 변경 | |
+| 289 | 말 그대로 전위, 중위, 후위 순위를 반환하면 되는 문제입니다 | 말 그대로 전위, 중위, 후위 순회를 반환하면 되는 문제입니다 | |
+| 291 | solution() 함수에서는 반환된 결과 리스트에서 마지막 공백을 제거한 뒤 리스트로 반환합니다. | solution() 함수에서는 반환된 결과 문자열에서 마지막 공백을 제거한 뒤 리스트로 반환합니다.
*공백이 제거되는 대상은 리스트가 아니라 문자열이 맞음 | |
+| 213 | h(x) = x mod m | h(x) = x mod k | |
+| 245 | line그림의 Muzi에 해당 되는 인덱스
14 12 13 14 로 되있음 | line그림의 Muzi에 해당 되는 인덱스
14 15 16 17 로 수정해야 함| |
+| 289 | 예시 그림은 [1, 5, 5, 4, 6, 4, 6]에 해당됨 | | |
+| 395 | 좀 더 명확한 예시로 확실한 이해가 될수 있게 추가 설명 필요하다고 판단, 합격조언 부분 | | |
+| 337 | disjoint_set[3] = 9면 노드 3의 부모 노드는 3임을 의미합니다. | disjoint_set[3] = 9면 노드 3의 부모 노드는 9임을 의미합니다. | |
+| 337 | 상호 베타적 관계를 가지는 집합 | 상호배타적 관계를 가지는 집합 | |
+| 413 | | | |
+| 640 | 프림 시간 복잡도 : (인접 리스트 활용 시 O(N^2)) |인접 리스트 를 인접 행렬 로 수정 | |
+| 478 | 9에서 2로의 이동은 9에서16의 이동으로 생각하면 됩니다.
| 9에서 2로의 이동은 9에서 14의 이동으로 생각하면 됩니다.
| |
+| 477 |  | | |
+| 478 | | | |
+| 400 | | | |
+| 475 | 화살을 맞춘다/못 맞춘다 두 상태가 있으므로 | 화살을 맞힌다/못 맞힌다 두 상태가 있으므로 | |
+| 599 | 이 배치 패턴을 dp[0] 코드를 작성해봅시다. | 이 배치 패턴을 작성해봅시다. | |
+| 602 | 그리고 파이썬 외에 다른 언어에서는 스택 오버 플로가 발생할 것입니다. | 그리고 파이썬 외에 다른 언어에서는 오버 플로가 발생할 것입니다. | |
+| 602 | # F(0) = 0, F(1) = 1 | # fib(0) = 0, fib(1) = 1 (각 코드에서 두 번째 줄, 총 2군데) | |
+| 546 | | | |
+| 650 | 문제 URL 잘못됨 |(https://school.programmers.co.kr/learn/courses/30/lessons/12982) | |
+| 652 | 예산이 0보다 크거나 같으면 모든 부서에 예산을 지원할 수 있는 것이므로 count를 반환하고 그렇지 않으면 -1을 반환합니다. | 이후 최종적으로 계산된 count를 반환 합니다. | |
+| 551 | | | |
+| 328 | | | |
+| 211 | 충돌의 의미는 서로 다른 서로 다른 | 충돌의 의미는 서로 다른 서로 다른 | |
+| 211 | 해시 테이블의 크기인 0과 N -1 사이의 값을 내야 합니다. | 해시 테이블의 크기가 N이므로, 인덱스에 해당되는 0과 N -1 사이의 값을 내야 합니다. | |
+| 115 | 행렬 A의 길이와 행렬 B의 길이가 | 행렬 A의 열의 길이와 행렬 B의 행의 길이가 그림과 같이 K로 | |
+| 387 | | | |
+| 386 | || |
+| 372 | | | |
+| 398 | | | |
+| 411 | || |
+| 400 | | | |
+| 643 | | | |
+| 638 | | | |
+| 607 | | | |
+| 608 | | | |
+| 560 | | | 좀더 나은 표현 |
+| 560 | | | 좀더 나은 표현 |
+| 561 | | | 좀더 나은 표현 |
+| 507 | | | |
+| 398 | | | |
+| 103 | | | |
+| 506 || | |
+| 586 || | |
+| 587 || | |
+| 593 || | |
+| 손노트 8 | |  | front와 rear 반대 |