[JooKangsan] 2025.02.06 (#38)

* fix: 에러 수정

* 문자열 뒤집기 / 기초

* Ctrl Z / 기초

* 크레인 인형뽑기 / 중급

* 다트게임 / 중급

* 순서쌍의 갯수 / 기초

* 점의 위치 구하기 / 기초

* 로그인 성공? / 기초

* 이상한 정렬 / 기초

* 카드 뭉치 / 기초

* feat: md 파일 추가

* 공원 산책 / 중급

* 햄버거 만들기 / 중급

* 모스부호 / 기초

* A로B만들기 / 기초

* 진료 순서 정하기 /기초

* 완주하지 못한 사람 / 기초

* hash.md 파일추가

* 키패드 / 심화

* tree.md 파일 추가

* 이진 트리의 중위 순위 / 기초

* SameTree / 기초

* 이진 트리 반전 / 기초

* 이진 트리 레벨 순서 순회

Author: JooKangsan

JooKangSan/[week4]hash/Athlete_who_did_not_finish.js

@@ -0,0 +1,6 @@
+function solution(participant, completion) {
+    participant.sort();
+    completion.sort();
+
+    return participant.find((name, i) => name !== completion[i]);
+}

JooKangSan/[week4]hash/Determine_the_order_of_treatment.js

@@ -0,0 +1,11 @@
+function solution(emergency) {
+    const orderMap = {};
+    
+    const sorted = [...emergency].sort((a, b) => b - a);
+    
+    sorted.forEach((value, index) => {
+        orderMap[value] = index + 1;
+    });
+    
+    return emergency.map(value => orderMap[value]);
+}

JooKangSan/[week4]hash/Hash.md

@@ -0,0 +1,161 @@
+# JavaScript Hash(Map) Algorithm
+
+## 1. 해시(Hash)란?
+키-값 쌍으로 데이터를 저장하는 자료구조로, 빠른 데이터 검색을 지원합니다.
+
+### 기본 특성
+- 고유한 키를 통해 값에 접근
+- 상수 시간 O(1)의 검색 복잡도
+- 충돌 처리 메커니즘 필요
+
+## 2. 자바스크립트에서 해시 구현 방법
+
+### 2.1 객체를 사용한 기본 구현
+```javascript
+// 기본적인 객체 사용
+const hash = {};
+
+// 데이터 추가
+hash['key'] = 'value';
+
+// 데이터 접근
+console.log(hash['key']); // 'value'
+
+// 데이터 삭제
+delete hash['key'];
+
+// 키 존재 확인
+console.log('key' in hash);
+```
+
+### 2.2 Map 객체 사용
+```javascript
+// Map 객체 생성
+const hashMap = new Map();
+
+// 데이터 추가
+hashMap.set('key', 'value');
+
+// 데이터 접근
+console.log(hashMap.get('key')); // 'value'
+
+// 데이터 삭제
+hashMap.delete('key');
+
+// 키 존재 확인
+console.log(hashMap.has('key'));
+```
+
+## 3. 해시의 주요 활용 사례
+
+### 3.1 빈도수 계산
+```javascript
+function countFrequency(arr) {
+    const frequency = {};
+    
+    for(const item of arr) {
+        frequency[item] = (frequency[item] || 0) + 1;
+    }
+    
+    return frequency;
+}
+
+// 사용 예시
+const arr = ['a', 'b', 'a', 'c', 'b', 'a'];
+console.log(countFrequency(arr)); // { a: 3, b: 2, c: 1 }
+```
+
+### 3.2 중복 제거
+```javascript
+function removeDuplicates(arr) {
+    const hash = {};
+    const result = [];
+    
+    for(const item of arr) {
+        if(!hash[item]) {
+            hash[item] = true;
+            result.push(item);
+        }
+    }
+    
+    return result;
+}
+
+// 사용 예시
+console.log(removeDuplicates([1, 2, 2, 3, 3, 3])); // [1, 2, 3]
+```
+
+### 3.3 Two Sum 문제
+```javascript
+function findTwoSum(nums, target) {
+    const hash = {};
+    
+    for(let i = 0; i < nums.length; i++) {
+        const complement = target - nums[i];
+        
+        if(complement in hash) {
+            return [hash[complement], i];
+        }
+        
+        hash[nums[i]] = i;
+    }
+    
+    return null;
+}
+
+// 사용 예시
+console.log(findTwoSum([2, 7, 11, 15], 9)); // [0, 1]
+```
+
+## 4. 성능 고려사항
+
+### 4.1 시간 복잡도
+- 삽입: O(1)
+- 삭제: O(1)
+- 검색: O(1)
+- 충돌이 많은 경우: O(n)
+
+### 4.2 공간 복잡도
+- O(n), 여기서 n은 저장된 키-값 쌍의 수
+
+### 4.3 주의사항
+1. 해시 충돌 처리
+   - 체이닝
+   - 개방 주소법
+
+2. 메모리 사용
+   - 적절한 초기 크기 설정
+   - 동적 크기 조정
+
+3. 키 선택
+   - 고른 분포의 해시값
+   - 효율적인 해시 함수
+
+## 5. Map vs Object 비교
+
+### 5.1 Map의 장점
+- 키로 모든 타입 사용 가능
+- 순서 보장
+- 크기를 쉽게 알 수 있음
+- 순회가 더 편리함
+
+### 5.2 Object의 장점
+- 리터럴 문법 지원
+- JSON과의 호환성
+- 프로토타입 체인
+- 더 적은 메모리 사용
+
+### 5.3 사용 예시
+```javascript
+// Map
+const map = new Map();
+map.set(1, 'one');
+map.set({}, 'object');
+map.set(() => {}, 'function');
+
+// Object
+const obj = {
+    1: 'one',
+    'key': 'value'
+};
+```

JooKangSan/[week4]hash/Make_B_from_A.js

@@ -0,0 +1,15 @@
+function solution(before, after) {
+    const hash = {};
+    
+    for(let char of before) {
+        hash[char] = (hash[char] || 0) + 1;
+    }
+    
+    for(let char of after) {
+        if(!hash[char]) return 0;
+        hash[char]--;
+    }
+    
+    // 모든 값이 0이면 1 반환
+    return Object.values(hash).every(count => count === 0) ? 1 : 0;
+}

JooKangSan/[week4]hash/Memory_Score.js

@@ -0,0 +1,9 @@
+function solution(name, yearning, photo) {
+    const scoreMap = {};
+
+    name.forEach((n, i) => scoreMap[n] = yearning[i]);
+    
+    return photo.map(p => 
+        p.reduce((sum, person) => sum + (scoreMap[person] || 0), 0)
+    );
+}

JooKangSan/[week4]hash/Morse_Code.js

@@ -0,0 +1,12 @@
+function solution(letter) {
+    // 모스부호 해시맵 생성
+    const morse = { 
+        '.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',
+        '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',
+        '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',
+        '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',
+        '-.--':'y','--..':'z'
+    };
+    
+    return letter.split(' ').map(match => morse[match]).join('');
+}

JooKangSan/[week4]hash/Ranking.js

@@ -0,0 +1,7 @@
+
+function solution(score) {
+    const sum = score.map((el) => (el[0] + el[1]));
+    let sortedSum = sum.slice().sort((a, b) => b - a);
+  
+    return sum.map((el) => sortedSum.indexOf(el) + 1);
+  }

JooKangSan/[week4]hash/keypad.js

@@ -0,0 +1,64 @@
+function solution(numbers, hand) {
+    // 키패드를 열 기준 2차원 배열로 정의
+    const keypad = [
+        [1, 4, 7, "*"],    // 왼쪽 열
+        [2, 5, 8, 0],      // 가운데 열
+        [3, 6, 9, "#"]     // 오른쪽 열
+    ]
+
+    // 각 숫자의 좌표를 Map으로 저장
+    const getPos = new Map()
+    // 열과 행 기준으로 좌표 저장
+    for(let x = 0; x < keypad.length; x++) {
+        for(let y = 0; y < keypad[x].length; y++) {
+            getPos.set(keypad[x][y], [x, y])
+        }
+    }
+
+    let left = getPos.get("*")     // 왼손 시작 위치
+    let right = getPos.get("#")    // 오른손 시작 위치
+
+    // 두 좌표 사이의 거리 계산
+    const getDist = ([x1, y1], [x2, y2]) => 
+        Math.abs(x1 - x2) + Math.abs(y1 - y2)
+
+    return numbers.map(num => {
+        const target = getPos.get(num)
+
+        // 첫 번째 열은 무조건 왼손
+        if(target[0] === 0) {
+            left = target
+            return "L"
+        }
+        
+        // 세 번째 열은 무조건 오른손
+        if(target[0] === 2) {
+            right = target
+            return "R"
+        }
+
+        // 가운데 열인 경우 거리 계산
+        const leftDist = getDist(left, target)
+        const rightDist = getDist(right, target)
+
+        // 거리가 같으면 주손잡이 기준
+        if(leftDist === rightDist) {
+            if(hand === "right") {
+                right = target
+                return "R"
+            } else {
+                left = target
+                return "L"
+            }
+        }
+
+        // 거리가 다르면 가까운 손 사용
+        if(leftDist < rightDist) {
+            left = target
+            return "L"
+        } else {
+            right = target
+            return "R"
+        }
+    }).join("")
+}

JooKangSan/[week5]Tree/Binary_Tree_Inorder_Traversal.js

@@ -0,0 +1,14 @@
+function inorderTraversal(root) {
+    const result = [];
+    
+    function inorder(node) {
+        if (!node) return;
+        
+        inorder(node.left);
+        result.push(node.val);
+        inorder(node.right);
+    }
+    
+    inorder(root);
+    return result;
+}

JooKangSan/[week5]Tree/Binary_Tree_Level_Order_Traversal.js

@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+function levelOrder(root){
+    if (!root) return [];
+  
+    const result = [];
+    const queue = [root];
+  
+    while (queue.length > 0) {
+      const levelSize = queue.length;
+      const levelNodes = [];
+  
+      for (let i = 0; i < levelSize; i++) {
+        const node = queue.shift();
+        levelNodes.push(node.val);
+  
+        if (node.left) queue.push(node.left);
+        if (node.right) queue.push(node.right);
+      }
+  
+      result.push(levelNodes); 
+    }
+  
+    return result;
+  };
+