[Blossssom] WEEK 10 solution

course-schedule/Blossssom.ts

@@ -0,0 +1,73 @@
+/**
+ * @pseudocode
+ * - 선행 수업에 대해 Map으로 정리
+ *
+ * - numCoureses 만큼의 반복 시작
+ *  - 탐색 시작
+ *  - 만약 방문 중인 상태 : true
+ *  - 만약 이미 방문한 상태 : false
+ *  - 현재 탐색한 값을 visit에 저장
+ *  - Map에 정리된 다음 수업 탐색
+ *
+ *
+ * @param numCourses
+ * @param prerequisites
+ * @returns
+ */
+
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+  const obj: Record<number, number[]> = prerequisites.reduce(
+    (acc: Record<number, number[]>, cur: number[]) => {
+      const [a, b] = cur;
+      acc[a] ? (acc[a] = [...acc[a], b]) : (acc[a] = [b]);
+      return acc;
+    },
+    {}
+  );
+
+  const visited = Array.from({ length: numCourses }, () => 0);
+
+  function hasCycle(current: number): boolean {
+    if (obj[current] === undefined) {
+      return false;
+    }
+    // 방문 중
+    if (visited[current] === 1) {
+      return true;
+    }
+
+    // 방문 완료
+    if (visited[current] === 2) {
+      return false;
+    }
+
+    visited[current] = 1;
+
+    for (const next of obj[current]) {
+      if (hasCycle(next)) {
+        return true;
+      }
+    }
+
+    visited[current] = 2;
+    return false;
+  }
+
+  for (let i = 0; i < numCourses; i++) {
+    if (hasCycle(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+const numCourses = 2;
+const prerequisites = [
+  [1, 0],
+  [0, 1],
+];
+
+canFinish(numCourses, prerequisites);
+
+
+

invert-binary-tree/Blossssom.ts

@@ -0,0 +1,53 @@
+class TreeNode {
+  val: number;
+  left: TreeNode | null;
+  right: TreeNode | null;
+  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+    this.val = val === undefined ? 0 : val;
+    this.left = left === undefined ? null : left;
+    this.right = right === undefined ? null : right;
+  }
+}
+
+/**
+ * @param root - TreeNode 객체
+ * @returns - 좌우 반전된 root 반환
+ * @description
+ * - 모든 트리를 탐색하기 위해 bfs로 진행
+ * - queue 배열을 만들어 각 단계의 하위 left, right를 push
+ */
+
+function invertTree(root: TreeNode | null): TreeNode | null {
+  if (root === null) {
+    return null;
+  }
+
+  const queue = [root];
+
+  while (queue.length) {
+    const current = queue.shift()!;
+
+    [current.left, current.right] = [current.right, current.left];
+
+    if (current.left !== null) {
+      queue.push(current.left);
+    }
+
+    if (current.right !== null) {
+      queue.push(current.right);
+    }
+  }
+
+  return root;
+}
+
+const root = new TreeNode(
+  4,
+  new TreeNode(2, new TreeNode(1), new TreeNode(3)),
+  new TreeNode(7, new TreeNode(6), new TreeNode(9))
+);
+
+invertTree(root);
+
+
+

jump-game/Blossssom.ts

@@ -0,0 +1,34 @@
+/**
+ * @pseudocode
+ * - 해당 칸에서 가장 멀리 갈 수 있는 값
+ * - 각 nums의 요소 반복
+ *  - 가장 멀리 갈 수 있는 값 업데이트
+ *  - if 가장 멀리 갈 수 있는 값이 현재 idx보다 작다면
+ *      - false
+ *  - if 가장 멀리 갈 수 있는 값이 nums의 마지막 idx보다 크거나 같다면
+ *      - true
+ * @param nums - 정수 배열
+ * @returns - 마지막 요소까지 접근이 가능한지 반환
+ */
+
+function canJump(nums: number[]): boolean {
+  let maxReach = 0;
+  for (let i = 0; i < nums.length; i++) {
+    if (i > maxReach) {
+      return false;
+    }
+
+    maxReach = Math.max(maxReach, i + nums[i]);
+
+    if (maxReach >= nums.length - 1) {
+      return true;
+    }
+  }
+
+  return true;
+}
+
+const nums = [2, 3, 1, 1, 4];
+canJump(nums);
+
+

missing-number/Blossssom.ts

@@ -0,0 +1,45 @@
+/**
+ * @pseudocode
+ * - Map 으로 탐색이 가능하도록 정리
+ * - nums의 length 만큼 돌며 없는 값 체크
+ *
+ * @param nums - 숫자 배열
+ * @returns - 순서 상 없는 숫자 반환
+ * @description
+ * - 다른 답 보니 다 더해서 없는 값 찾으면 그만이구나;;;
+ *
+ */
+
+// function missingNumber(nums: number[]): number {
+//   const numMap = new Map();
+
+//   for (const num of nums) {
+//     numMap.set(num, true);
+//   }
+
+//   for (let i = 0; i < nums.length; i++) {
+//     if (!numMap.has(i)) {
+//       return i;
+//     }
+//   }
+//   return nums.length;
+// }
+
+function missingNumber(nums: number[]): number {
+  let test = 0;
+  let sum = 0;
+  for (let i = 0; i < nums.length; i++) {
+    test += i;
+    sum += nums[i];
+  }
+
+  test += nums.length;
+
+  return Math.abs(test - sum);
+}
+
+const nums = [3, 0, 1];
+missingNumber(nums);
+
+
+

search-in-rotated-sorted-array/Blossssom.ts

@@ -0,0 +1,50 @@
+/**
+ * @param nums - 정렬된 정수 배열
+ * @param target - 찾는 수
+ * @returns - 왼쪽으로 몇 번 이동해야 target을 찾는지 반환 없으면 -1
+ * @description
+ * - 풀이 1. 이게 통과가 되네?
+ * - 풀이 2. 중앙 부터 좌우 값을 줄여가며 탐색 - 이진탐색
+ */
+
+// function search(nums: number[], target: number): number {
+//   let result = -1;
+//   for (let i = 0; i < nums.length; i++) {
+//     if (nums[i] === target) {
+//       result = i;
+//     }
+//   }
+
+//   return result;
+// }
+
+function search(nums: number[], target: number): number {
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left <= right) {
+    let mid = Math.floor((left + right) / 2);
+
+    if (nums[mid] === target) {
+      return mid;
+    }
+
+    if (
+      (nums[left] <= target && target < nums[mid]) ||
+      (nums[mid] < nums[left] && target > nums[right]) ||
+      (nums[left] > nums[mid] && target < nums[mid])
+    ) {
+      right = mid - 1;
+    } else {
+      left = mid + 1;
+    }
+  }
+
+  return -1;
+}
+
+const nums = [4, 5, 6, 7, 0, 1, 2];
+const target = 0;
+search(nums, target);
+
+