From e2838326a01134e8d4d611055b23753cc1376f8c Mon Sep 17 00:00:00 2001
From: soobing <qls0147@naver.com>
Date: Mon, 20 Apr 2026 21:56:26 +0900
Subject: [PATCH] refactor(soobing): rename soobing3.ts to soobing.ts

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 3sum/{soobing3.ts => soobing.ts}              |  0
 climbing-stairs/soobing.ts                    | 42 +++------
 climbing-stairs/soobing3.ts                   | 14 ---
 coin-change/{soobing3.ts => soobing.ts}       |  0
 combination-sum/{soobing3.ts => soobing.ts}   |  0
 contains-duplicate/soobing.ts                 | 15 +--
 contains-duplicate/soobing3.ts                | 11 ---
 decode-ways/{soobing3.ts => soobing.ts}       |  0
 .../{soobing3.ts => soobing.ts}               |  0
 house-robber/soobing.ts                       | 42 ++-------
 house-robber/soobing3.ts                      | 10 --
 .../{soobing3.ts => soobing.ts}               |  0
 .../{soobing3.ts => soobing.ts}               |  0
 maximum-subarray/soobing.ts                   | 16 ++--
 maximum-subarray/soobing3.ts                  | 11 ---
 .../{soobing3.ts => soobing.ts}               |  0
 number-of-islands/soobing.ts                  | 92 +------------------
 number-of-islands/soobing3.ts                 |  9 --
 product-of-array-except-self/soobing.ts       | 23 ++---
 product-of-array-except-self/soobing3.ts      | 20 ----
 .../{soobing3.ts => soobing.ts}               |  0
 two-sum/soobing.ts                            | 42 +++++----
 two-sum/soobing3.ts                           | 29 ------
 valid-anagram/soobing.ts                      | 58 +++---------
 valid-anagram/soobing3.ts                     | 20 ----
 valid-palindrome/{soobing3.ts => soobing.ts}  |  0
 validate-binary-search-tree/soobing.ts        | 55 ++++-------
 validate-binary-search-tree/soobing3.ts       | 24 -----
 word-search/{soobing3.ts => soobing.ts}       |  0
 29 files changed, 109 insertions(+), 424 deletions(-)
 rename 3sum/{soobing3.ts => soobing.ts} (100%)
 delete mode 100644 climbing-stairs/soobing3.ts
 rename coin-change/{soobing3.ts => soobing.ts} (100%)
 rename combination-sum/{soobing3.ts => soobing.ts} (100%)
 delete mode 100644 contains-duplicate/soobing3.ts
 rename decode-ways/{soobing3.ts => soobing.ts} (100%)
 rename find-minimum-in-rotated-sorted-array/{soobing3.ts => soobing.ts} (100%)
 delete mode 100644 house-robber/soobing3.ts
 rename longest-consecutive-sequence/{soobing3.ts => soobing.ts} (100%)
 rename maximum-depth-of-binary-tree/{soobing3.ts => soobing.ts} (100%)
 delete mode 100644 maximum-subarray/soobing3.ts
 rename merge-two-sorted-lists/{soobing3.ts => soobing.ts} (100%)
 delete mode 100644 number-of-islands/soobing3.ts
 delete mode 100644 product-of-array-except-self/soobing3.ts
 rename top-k-frequent-elements/{soobing3.ts => soobing.ts} (100%)
 delete mode 100644 two-sum/soobing3.ts
 delete mode 100644 valid-anagram/soobing3.ts
 rename valid-palindrome/{soobing3.ts => soobing.ts} (100%)
 delete mode 100644 validate-binary-search-tree/soobing3.ts
 rename word-search/{soobing3.ts => soobing.ts} (100%)

diff --git a/3sum/soobing3.ts b/3sum/soobing.ts
similarity index 100%
rename from 3sum/soobing3.ts
rename to 3sum/soobing.ts
diff --git a/climbing-stairs/soobing.ts b/climbing-stairs/soobing.ts
index 3a95e3a0da..79efb4f201 100644
--- a/climbing-stairs/soobing.ts
+++ b/climbing-stairs/soobing.ts
@@ -1,34 +1,14 @@
-/**
- * 문제 유형
- * - DP (피보나치)
- *
- * 문제 설명
- * - 계단을 올라가는 방법의 수를 구하기
- *
- * 아이디어
- * 1) 피보나치 수열 활용
- * - climbStairs(n) = climbStairs(n-1) + climbStairs(n-2)
- */
-function climbStairsBottomUp(n: number): number {
-  function fibonacci(n: number, memo = new Map<number, number>()) {
-    if (n === 1) return 1;
-    if (n === 2) return 2;
+function climbStairs(n: number): number {
+  const memo = new Map<number, number>();
+  
+  function dp (n: number): number {
+      if(n <= 1) return 1;
+      if(memo.has(n)) return memo.get(n)!;
 
-    if (memo.has(n)) return memo.get(n);
-    const result = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
-    memo.set(n, result);
-    return result;
+      const result = dp(n-1) + dp(n-2);
+      memo.set(n, result);
+      return result;
   }
-  return fibonacci(n);
-}
 
-function climbStairsTopDown(n: number): number {
-  const dp = new Array(n + 1).fill(0);
-  dp[1] = 1;
-  dp[2] = 2;
-
-  for (let i = 3; i <= n; i++) {
-    dp[i] = dp[i - 1] + dp[i - 2];
-  }
-  return dp[n];
-}
+  return dp(n);
+};
diff --git a/climbing-stairs/soobing3.ts b/climbing-stairs/soobing3.ts
deleted file mode 100644
index 79efb4f201..0000000000
--- a/climbing-stairs/soobing3.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-function climbStairs(n: number): number {
-  const memo = new Map<number, number>();
-  
-  function dp (n: number): number {
-      if(n <= 1) return 1;
-      if(memo.has(n)) return memo.get(n)!;
-
-      const result = dp(n-1) + dp(n-2);
-      memo.set(n, result);
-      return result;
-  }
-
-  return dp(n);
-};
diff --git a/coin-change/soobing3.ts b/coin-change/soobing.ts
similarity index 100%
rename from coin-change/soobing3.ts
rename to coin-change/soobing.ts
diff --git a/combination-sum/soobing3.ts b/combination-sum/soobing.ts
similarity index 100%
rename from combination-sum/soobing3.ts
rename to combination-sum/soobing.ts
diff --git a/contains-duplicate/soobing.ts b/contains-duplicate/soobing.ts
index a8ce40ac0d..01d03961d4 100644
--- a/contains-duplicate/soobing.ts
+++ b/contains-duplicate/soobing.ts
@@ -1,10 +1,11 @@
 function containsDuplicate(nums: number[]): boolean {
-  const map = new Map();
-  for (let i = 0; i < nums.length; i++) {
-    if (map.get(nums[i])) {
-      return true;
-    } else map.set(nums[i], 1);
+  const checkMap = new Map();
+  for(const n of nums) {
+      if(checkMap.has(n)) {
+          return true;
+      } else {
+          checkMap.set(n, 1);
+      }
   }
-
   return false;
-}
+};
diff --git a/contains-duplicate/soobing3.ts b/contains-duplicate/soobing3.ts
deleted file mode 100644
index 01d03961d4..0000000000
--- a/contains-duplicate/soobing3.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-function containsDuplicate(nums: number[]): boolean {
-  const checkMap = new Map();
-  for(const n of nums) {
-      if(checkMap.has(n)) {
-          return true;
-      } else {
-          checkMap.set(n, 1);
-      }
-  }
-  return false;
-};
diff --git a/decode-ways/soobing3.ts b/decode-ways/soobing.ts
similarity index 100%
rename from decode-ways/soobing3.ts
rename to decode-ways/soobing.ts
diff --git a/find-minimum-in-rotated-sorted-array/soobing3.ts b/find-minimum-in-rotated-sorted-array/soobing.ts
similarity index 100%
rename from find-minimum-in-rotated-sorted-array/soobing3.ts
rename to find-minimum-in-rotated-sorted-array/soobing.ts
diff --git a/house-robber/soobing.ts b/house-robber/soobing.ts
index ad17c73f30..32d0bed9e9 100644
--- a/house-robber/soobing.ts
+++ b/house-robber/soobing.ts
@@ -1,34 +1,10 @@
-/**
- * 문제 설명
- * - 주어진 배열의 시작과 끝이 연결되어 있는 원형이라고 할 경우에, 이웃하는 집은 털 수 없고 최대로 털 수 있는 돈을 구하는 문제
- *
- * 아이디어
- * 1) 동적 계획법(Dynamic Programming) 활용
- *   - 원형 구조이므로 첫번째 집과 마지막집은 동시에 털 수 없음
- *   - 따라서 두 가지 경우로 나누어 계산하고, 두 결과 중 더 큰 값을 반환
- * 2) 선형 배열에 대한 최대 금액 계산
- *   - 매 순회마다 현재 집을 털 경우(prev2 + num)와 털지 않을 경우(prev1) 중 큰 값을 선택
- *   - 최종적으로 prev1에 최대값이 저장
- */
-function robLinear(nums: number[]) {
-  let prev1 = 0;
-  let prev2 = 0;
-
-  for (const num of nums) {
-    const temp = prev1;
-    prev1 = Math.max(prev2 + num, prev1);
-    prev2 = temp;
-  }
-
-  return prev1;
-}
-
 function rob(nums: number[]): number {
-  if (nums.length === 1) return nums[0];
-  if (nums.length === 2) return Math.max(nums[0], nums[1]);
-
-  const temp1 = robLinear(nums.slice(0, nums.length - 1));
-  const temp2 = robLinear(nums.slice(1));
-
-  return Math.max(temp1, temp2);
-}
+  const dp = new Array(nums.length);
+  dp[0] = nums[0];
+  dp[1] = Math.max(nums[0], nums[1]);
+  
+  for(let i = 2; i < nums.length; i++) {
+      dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
+  }
+  return dp[nums.length - 1];
+};
diff --git a/house-robber/soobing3.ts b/house-robber/soobing3.ts
deleted file mode 100644
index 32d0bed9e9..0000000000
--- a/house-robber/soobing3.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-function rob(nums: number[]): number {
-  const dp = new Array(nums.length);
-  dp[0] = nums[0];
-  dp[1] = Math.max(nums[0], nums[1]);
-  
-  for(let i = 2; i < nums.length; i++) {
-      dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
-  }
-  return dp[nums.length - 1];
-};
diff --git a/longest-consecutive-sequence/soobing3.ts b/longest-consecutive-sequence/soobing.ts
similarity index 100%
rename from longest-consecutive-sequence/soobing3.ts
rename to longest-consecutive-sequence/soobing.ts
diff --git a/maximum-depth-of-binary-tree/soobing3.ts b/maximum-depth-of-binary-tree/soobing.ts
similarity index 100%
rename from maximum-depth-of-binary-tree/soobing3.ts
rename to maximum-depth-of-binary-tree/soobing.ts
diff --git a/maximum-subarray/soobing.ts b/maximum-subarray/soobing.ts
index 5cd3d4be76..9cd0073ed8 100644
--- a/maximum-subarray/soobing.ts
+++ b/maximum-subarray/soobing.ts
@@ -1,9 +1,11 @@
 function maxSubArray(nums: number[]): number {
-  let currentSum = nums[0];
-  let maxSum = nums[0];
-  for (let i = 1; i < nums.length; i++) {
-    currentSum = Math.max(nums[i], currentSum + nums[i]);
-    maxSum = Math.max(maxSum, currentSum);
+  let max = nums[0];
+  const dp = new Array(nums.length).fill(0);
+  dp[0] = Math.max(0, nums[0]);
+
+  for(let i = 1; i < nums.length; i++) {
+      dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);
+      max = Math.max(dp[i], max);
   }
-  return maxSum;
-}
+  return max;
+};
diff --git a/maximum-subarray/soobing3.ts b/maximum-subarray/soobing3.ts
deleted file mode 100644
index 9cd0073ed8..0000000000
--- a/maximum-subarray/soobing3.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-function maxSubArray(nums: number[]): number {
-  let max = nums[0];
-  const dp = new Array(nums.length).fill(0);
-  dp[0] = Math.max(0, nums[0]);
-
-  for(let i = 1; i < nums.length; i++) {
-      dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);
-      max = Math.max(dp[i], max);
-  }
-  return max;
-};
diff --git a/merge-two-sorted-lists/soobing3.ts b/merge-two-sorted-lists/soobing.ts
similarity index 100%
rename from merge-two-sorted-lists/soobing3.ts
rename to merge-two-sorted-lists/soobing.ts
diff --git a/number-of-islands/soobing.ts b/number-of-islands/soobing.ts
index 8fdc56d4a9..5d2a326d9b 100644
--- a/number-of-islands/soobing.ts
+++ b/number-of-islands/soobing.ts
@@ -1,91 +1,9 @@
-/**
- * 문제 설명
- * - 2차원 그리드에서 섬의 갯수를 구하는 문제
- *
- * 조건
- * - 가로, 세로가 1로 인접해있는 경우 같은 섬으로 간주
- *
- * 아이디어
- * - 경로 탐색, 네트워크, 조합 유형이 나오면 '그래프 탐색 알고리즘'을 떠울린다.
- * 1) DFS (재귀)
- * 2) BFS (링크드리스트 or 큐)
- *
- */
-
-function numIslands(grid: string[][]): number {
-  const rows = grid.length;
-  const cols = grid[0].length;
+function hammingWeight(n: number): number {
   let count = 0;
-  function dfs(r: number, c: number) {
-    if (r < 0 || c < 0 || r >= rows || c >= cols || grid[r][c] === "0") return;
-
-    grid[r][c] = "0";
-    dfs(r - 1, c);
-    dfs(r + 1, c);
-    dfs(r, c - 1);
-    dfs(r, c + 1);
-  }
-
-  for (let r = 0; r < rows; r++) {
-    for (let c = 0; c < cols; c++) {
-      if (grid[r][c] === "1") {
-        count++;
-        dfs(r, c);
-      }
-    }
-  }
-  return count;
-}
-
-/**
- * 
- * BFS version
-
-function numIslands(grid: string[][]): number {
-  const rows = grid.length;
-  const cols = grid[0].length;
-  let count = 0;
-
-  const directions = [
-    [0, 1],
-    [1, 0],
-    [0, -1],
-    [-1, 0],
-  ];
-  function bfs(r: number, c: number) {
-    const queue = [[r, c]];
-    grid[r][c] = "0";
-
-    while (queue.length) {
-      const [row, col] = queue.shift()!;
-
-      for (const [dr, dc] of directions) {
-        const newRow = row + dr;
-        const newCol = col + dc;
-
-        if (
-          newRow >= 0 &&
-          newRow < rows &&
-          newCol >= 0 &&
-          newCol < cols &&
-          grid[newRow][newCol] === "1"
-        ) {
-          queue.push([newRow, newCol]);
-          grid[newRow][newCol] = "0";
-        }
-      }
-    }
-  }
-
-  for (let r = 0; r < rows; r++) {
-    for (let c = 0; c < cols; c++) {
-      if (grid[r][c] === "1") {
-        count++;
-        bfs(r, c);
+  for(let i = 31; i >= 0; i--) {
+      if((n >> i) & 1) {
+          count++;
       }
-    }
   }
   return count;
-}
-
- */
+};
diff --git a/number-of-islands/soobing3.ts b/number-of-islands/soobing3.ts
deleted file mode 100644
index 5d2a326d9b..0000000000
--- a/number-of-islands/soobing3.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-function hammingWeight(n: number): number {
-  let count = 0;
-  for(let i = 31; i >= 0; i--) {
-      if((n >> i) & 1) {
-          count++;
-      }
-  }
-  return count;
-};
diff --git a/product-of-array-except-self/soobing.ts b/product-of-array-except-self/soobing.ts
index c1caa1a859..e72350b9f7 100644
--- a/product-of-array-except-self/soobing.ts
+++ b/product-of-array-except-self/soobing.ts
@@ -1,19 +1,20 @@
 function productExceptSelf(nums: number[]): number[] {
-  const left = Array(nums.length).fill(1);
-  const right = Array(nums.length).fill(1);
-  const result = Array(nums.length);
+  const n = nums.length;
+  const left = new Array(n).fill(1);
+  const right = new Array(n).fill(1);
+  const result = new Array(n).fill(1);
 
-  for (let i = 1; i < nums.length; i++) {
-    left[i] = left[i - 1] * nums[i - 1];
+  for (let i = 1; i < n; i++) {
+      left[i] = nums[i-1] * left[i - 1];
   }
 
-  for (let i = nums.length - 2; i >= 0; i--) {
-    right[i] = right[i + 1] * nums[i + 1];
+  for (let i = n - 2; i >= 0; i--) {
+      right[i] = nums[i+1] * right[i + 1];
   }
 
-  for (let i = 0; i < nums.length; i++) {
-    result[i] = left[i] * right[i];
+  for (let i = 0; i < n; i++) {
+      result[i] = left[i] * right[i];
   }
-
+  
   return result;
-}
+};
diff --git a/product-of-array-except-self/soobing3.ts b/product-of-array-except-self/soobing3.ts
deleted file mode 100644
index e72350b9f7..0000000000
--- a/product-of-array-except-self/soobing3.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-function productExceptSelf(nums: number[]): number[] {
-  const n = nums.length;
-  const left = new Array(n).fill(1);
-  const right = new Array(n).fill(1);
-  const result = new Array(n).fill(1);
-
-  for (let i = 1; i < n; i++) {
-      left[i] = nums[i-1] * left[i - 1];
-  }
-
-  for (let i = n - 2; i >= 0; i--) {
-      right[i] = nums[i+1] * right[i + 1];
-  }
-
-  for (let i = 0; i < n; i++) {
-      result[i] = left[i] * right[i];
-  }
-  
-  return result;
-};
diff --git a/top-k-frequent-elements/soobing3.ts b/top-k-frequent-elements/soobing.ts
similarity index 100%
rename from top-k-frequent-elements/soobing3.ts
rename to top-k-frequent-elements/soobing.ts
diff --git a/two-sum/soobing.ts b/two-sum/soobing.ts
index dc909c1a18..2d4f5996e2 100644
--- a/two-sum/soobing.ts
+++ b/two-sum/soobing.ts
@@ -1,27 +1,29 @@
-// 1. Brute force
 function twoSum(nums: number[], target: number): number[] {
-  for (let i = 0; i < nums.length - 1; i++) {
-    for (let j = i + 1; j < nums.length; j++) {
-      if (nums[i] + nums[j] === target) {
-        return [i, j];
+  const map = new Map<number, number[]>();
+  for(let i = 0; i < nums.length; i++) {
+      const current = map.get(nums[i]);
+      if(current) {
+          current.push(i);
+      } else {
+          map.set(nums[i], [i]);
       }
-    }
   }
-  return [];
-}
 
-// 2. Hashmap
-function twoSum(nums: number[], target: number): number[] {
-  const map = new Map();
-  for (let i = 0; i < nums.length; i++) {
-    map.set(nums[i], i);
-  }
+  nums.sort((a, b) => a - b);
+  let left = 0;
+  let right = nums.length - 1;
 
-  for (let i = 0; i < nums.length; i++) {
-    const targetIndex = map.get(target - nums[i]);
-    if (targetIndex && targetIndex !== i) {
-      return [i, targetIndex];
-    }
+  while(left < right) {
+      if(nums[left] + nums[right] === target) {
+          return [map.get(nums[left])?.pop() ?? 0, map.get(nums[right])?.pop() ?? 0];
+      }
+
+      if(nums[left] + nums[right] > target) {
+          right--;
+      } else {
+          left++;
+      }
   }
+
   return [];
-}
+};
diff --git a/two-sum/soobing3.ts b/two-sum/soobing3.ts
deleted file mode 100644
index 2d4f5996e2..0000000000
--- a/two-sum/soobing3.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-function twoSum(nums: number[], target: number): number[] {
-  const map = new Map<number, number[]>();
-  for(let i = 0; i < nums.length; i++) {
-      const current = map.get(nums[i]);
-      if(current) {
-          current.push(i);
-      } else {
-          map.set(nums[i], [i]);
-      }
-  }
-
-  nums.sort((a, b) => a - b);
-  let left = 0;
-  let right = nums.length - 1;
-
-  while(left < right) {
-      if(nums[left] + nums[right] === target) {
-          return [map.get(nums[left])?.pop() ?? 0, map.get(nums[right])?.pop() ?? 0];
-      }
-
-      if(nums[left] + nums[right] > target) {
-          right--;
-      } else {
-          left++;
-      }
-  }
-
-  return [];
-};
diff --git a/valid-anagram/soobing.ts b/valid-anagram/soobing.ts
index 17869f5d53..66e505f804 100644
--- a/valid-anagram/soobing.ts
+++ b/valid-anagram/soobing.ts
@@ -1,52 +1,20 @@
-/**
- * 문제 유형
- * - String
- *
- * 문제 설명
- * - 두 문자열이 애너그램인지 확인하기
- *
- * 아이디어
- * 1) 문자열을 맵으로 변환하고, 정렬 후 비교하기
- * 2) 문자열 정렬 없이 하나의 map으로 더하고 빼기하여 0인지 확인하기
- */
-function mapString(str: string) {
-  const map = new Map<string, number>();
-  for (let i = 0; i < str.length; i++) {
-    map.set(str[i], (map.get(str[i]) || 0) + 1);
-  }
-  return map;
-}
 function isAnagram(s: string, t: string): boolean {
-  const sMap = mapString(s);
-  const tMap = mapString(t);
-
-  const sKeys = [...sMap.keys()].sort().join("");
-  const tKeys = [...tMap.keys()].sort().join("");
+  if(s.length !== t.length) return false;
+  
+  const sMap = new Map<string, number>();
+  const tMap = new Map<string, number>();
 
-  if (sKeys !== tKeys) return false;
-
-  for (let i = 0; i < sKeys.length; i++) {
-    const key = sKeys[i];
-    if (sMap.get(key) !== tMap.get(key)) return false;
+  for(const s_char of s) {
+      sMap.set(s_char, (sMap.get(s_char) ?? 0) + 1);
   }
 
-  return true;
-}
-
-// 아이디어 2
-function isAnagramDeveloped(s: string, t: string): boolean {
-  if (s.length !== t.length) return false;
-
-  const count = new Map<string, number>();
-
-  for (let i = 0; i < s.length; i++) {
-    count.set(s[i], (count.get(s[i]) || 0) + 1);
-    count.set(t[i], (count.get(t[i]) || 0) - 1);
+  for(const t_char of t) {
+      tMap.set(t_char, (tMap.get(t_char) ?? 0) + 1);
   }
 
-  for (const val of count.values()) {
-    if (val !== 0) return false;
+  if(sMap.size !== tMap.size) return false;
+  for(const [sKey, sValue] of sMap) {
+      if(sValue !== tMap.get(sKey)) return false;
   }
-
-  return true;
-}
+  return true
+};
diff --git a/valid-anagram/soobing3.ts b/valid-anagram/soobing3.ts
deleted file mode 100644
index 66e505f804..0000000000
--- a/valid-anagram/soobing3.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-function isAnagram(s: string, t: string): boolean {
-  if(s.length !== t.length) return false;
-  
-  const sMap = new Map<string, number>();
-  const tMap = new Map<string, number>();
-
-  for(const s_char of s) {
-      sMap.set(s_char, (sMap.get(s_char) ?? 0) + 1);
-  }
-
-  for(const t_char of t) {
-      tMap.set(t_char, (tMap.get(t_char) ?? 0) + 1);
-  }
-
-  if(sMap.size !== tMap.size) return false;
-  for(const [sKey, sValue] of sMap) {
-      if(sValue !== tMap.get(sKey)) return false;
-  }
-  return true
-};
diff --git a/valid-palindrome/soobing3.ts b/valid-palindrome/soobing.ts
similarity index 100%
rename from valid-palindrome/soobing3.ts
rename to valid-palindrome/soobing.ts
diff --git a/validate-binary-search-tree/soobing.ts b/validate-binary-search-tree/soobing.ts
index cae6c35b9d..0d77d8bdff 100644
--- a/validate-binary-search-tree/soobing.ts
+++ b/validate-binary-search-tree/soobing.ts
@@ -1,39 +1,24 @@
 /**
- * 문제 유형
- * - Tree
- *
- * 문제 설명
- * - 이진 탐색 트리가 맞는지 확인하기
- *
- * 아이디어
- * 1) 중위 순회 후 정렬된 배열인지 확인
- *
+ * Definition for a binary tree node.
+ * 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)
+ *     }
+ * }
  */
-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;
-  }
-}
 
-function isSorted(arr: number[]) {
-  for (let i = 1; i < arr.length; i++) {
-    if (arr[i - 1] >= arr[i]) return false;
-  }
-  return true;
-}
-function inorder(node: TreeNode | null, arr: number[]) {
-  if (node === null) return;
-  inorder(node.left, arr);
-  arr.push(node.val);
-  inorder(node.right, arr);
-}
 function isValidBST(root: TreeNode | null): boolean {
-  const sortedArray: number[] = [];
-  inorder(root, sortedArray);
-  return isSorted(sortedArray);
-}
+  function validate(node: TreeNode | null, min: number, max: number){
+      if(node === null) return true;
+
+      if(node.val <= min || node.val >= max) return false;
+
+      return validate(node.left, min, node.val) && validate(node.right, node.val, max)
+  }
+  return validate(root, -Infinity, Infinity);
+};
diff --git a/validate-binary-search-tree/soobing3.ts b/validate-binary-search-tree/soobing3.ts
deleted file mode 100644
index 0d77d8bdff..0000000000
--- a/validate-binary-search-tree/soobing3.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * Definition for a binary tree node.
- * 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)
- *     }
- * }
- */
-
-function isValidBST(root: TreeNode | null): boolean {
-  function validate(node: TreeNode | null, min: number, max: number){
-      if(node === null) return true;
-
-      if(node.val <= min || node.val >= max) return false;
-
-      return validate(node.left, min, node.val) && validate(node.right, node.val, max)
-  }
-  return validate(root, -Infinity, Infinity);
-};
diff --git a/word-search/soobing3.ts b/word-search/soobing.ts
similarity index 100%
rename from word-search/soobing3.ts
rename to word-search/soobing.ts