diff --git a/berrnuda/10week/139_Word_Break.js b/berrnuda/10week/139_Word_Break.js
new file mode 100644
index 0000000..ed24d03
--- /dev/null
+++ b/berrnuda/10week/139_Word_Break.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {boolean}
+ */
+var wordBreak = function (s, wordDict) {
+  const wordSet = new Set(wordDict);
+  const dp = new Array(s.length + 1).fill(false);
+
+  dp[0] = true;
+
+  for (let i = 1; i <= s.length; i++) {
+    for (let word of wordSet) {
+      if (
+        i >= word.length &&
+        dp[i - word.length] &&
+        s.slice(i - word.length, i) === word
+      ) {
+        dp[i] = true;
+        break;
+      }
+    }
+  }
+
+  return dp[s.length];
+};
diff --git a/berrnuda/10week/215_Kth_Largest_Element_in_an_Array.js b/berrnuda/10week/215_Kth_Largest_Element_in_an_Array.js
new file mode 100644
index 0000000..c55cd74
--- /dev/null
+++ b/berrnuda/10week/215_Kth_Largest_Element_in_an_Array.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var findKthLargest = function (nums, k) {
+  const minPriQue = new MinPriorityQueue();
+  for (let i = 0; i < nums.length; i++) {
+    minPriQue.enqueue(nums[i]);
+    if (minPriQue.size() > k) {
+      minPriQue.dequeue();
+    }
+  }
+  return minPriQue.front().element;
+};
diff --git a/berrnuda/10week/235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.js b/berrnuda/10week/235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.js
new file mode 100644
index 0000000..16b906d
--- /dev/null
+++ b/berrnuda/10week/235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.js
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function (root, p, q) {
+  while (root) {
+    if (p.val < root.val && q.val < root.val) {
+      root = root.left;
+    } else if (p.val > root.val && q.val > root.val) {
+      root = root.right;
+    } else {
+      return root;
+    }
+  }
+  return null;
+};
diff --git a/berrnuda/10week/56_Merge_Intervals.js b/berrnuda/10week/56_Merge_Intervals.js
new file mode 100644
index 0000000..b23d85f
--- /dev/null
+++ b/berrnuda/10week/56_Merge_Intervals.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function (intervals) {
+  let n = intervals.length;
+
+  intervals.sort((a, b) => a[0] - b[0]);
+
+  let result = [];
+  let cur = intervals[0];
+
+  for (let i = 1; i < n; i++) {
+    if (cur[1] >= intervals[i][0]) cur[1] = Math.max(cur[1], intervals[i][1]);
+    else {
+      result.push(cur);
+      cur = intervals[i];
+    }
+  }
+
+  result.push(cur);
+
+  return result;
+};
diff --git a/berrnuda/11week/2013_Detect_Squares.js b/berrnuda/11week/2013_Detect_Squares.js
new file mode 100644
index 0000000..90721b6
--- /dev/null
+++ b/berrnuda/11week/2013_Detect_Squares.js
@@ -0,0 +1,43 @@
+var DetectSquares = function () {
+  this.ptsCount = new Map();
+};
+
+/**
+ * @param {number[]} point
+ * @return {void}
+ */
+DetectSquares.prototype.add = function (point) {
+  const key = `${point[0]}/${point[1]}`;
+  this.ptsCount.set(key, (this.ptsCount.get(key) || 0) + 1);
+};
+
+/**
+ * @param {number[]} point
+ * @return {number}
+ */
+DetectSquares.prototype.count = function (point) {
+  const [qx, qy] = point;
+  let result = 0;
+
+  for (const key of this.ptsCount.keys()) {
+    const [px, py] = key.split("/").map(Number);
+
+    if (Math.abs(px - qx) === Math.abs(py - qy) && px !== qx && py !== qy) {
+      const key1 = `${px}/${qy}`;
+      const key2 = `${qx}/${py}`;
+      result +=
+        (this.ptsCount.get(key) || 0) *
+        (this.ptsCount.get(key1) || 0) *
+        (this.ptsCount.get(key2) || 0);
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Your DetectSquares object will be instantiated and called as such:
+ * var obj = new DetectSquares()
+ * obj.add(point)
+ * var param_2 = obj.count(point)
+ */
diff --git a/berrnuda/11week/39_Combination_Sum.js b/berrnuda/11week/39_Combination_Sum.js
new file mode 100644
index 0000000..37596ac
--- /dev/null
+++ b/berrnuda/11week/39_Combination_Sum.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function (candidates, target) {
+  const result = [];
+  const stack = [[[], 0, 0]];
+
+  while (stack.length > 0) {
+    const [currentCombination, currentSum, startIndex] = stack.pop();
+
+    if (currentSum === target) {
+      result.push(currentCombination);
+      continue;
+    }
+
+    if (currentSum > target) continue;
+
+    for (let i = startIndex; i < candidates.length; i++) {
+      stack.push([
+        [...currentCombination, candidates[i]],
+        currentSum + candidates[i],
+        i,
+      ]);
+    }
+  }
+
+  return result;
+};
diff --git a/berrnuda/11week/57_Insert_Interval.js b/berrnuda/11week/57_Insert_Interval.js
new file mode 100644
index 0000000..c6a2692
--- /dev/null
+++ b/berrnuda/11week/57_Insert_Interval.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} intervals
+ * @param {number[]} newInterval
+ * @return {number[][]}
+ */
+var insert = function (intervals, newInterval) {
+  intervals.push(newInterval);
+  intervals.sort((a, b) => a[0] - b[0]);
+
+  let res = [intervals[0]];
+
+  for (let i = 1; i < intervals.length; i++) {
+    if (res[res.length - 1][1] >= intervals[i][0]) {
+      res[res.length - 1][1] = Math.max(
+        res[res.length - 1][1],
+        intervals[i][1]
+      );
+    } else {
+      res.push(intervals[i]);
+    }
+  }
+
+  return res;
+};
diff --git a/berrnuda/11week/743_Network_Delay_Time.js b/berrnuda/11week/743_Network_Delay_Time.js
new file mode 100644
index 0000000..7af3a57
--- /dev/null
+++ b/berrnuda/11week/743_Network_Delay_Time.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[][]} times
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+var networkDelayTime = function (times, n, k) {
+  const node = Array.from({ length: n + 1 }, () => []);
+  for (const [u, v, w] of times) node[u].push([v, w]);
+
+  const dist = new Array(n + 1).fill(Infinity);
+  dist[k] = 0;
+
+  const visited = new Array(n + 1).fill(false);
+
+  for (let i = 1; i <= n; i++) {
+    let minNode = -1;
+    for (let j = 1; j <= n; j++) {
+      if (!visited[j] && (minNode === -1 || dist[j] < dist[minNode]))
+        minNode = j;
+    }
+
+    if (dist[minNode] === Infinity) break;
+
+    visited[minNode] = true;
+
+    for (const [neighbor, weight] of node[minNode]) {
+      const newDist = dist[minNode] + weight;
+      if (newDist < dist[neighbor]) dist[neighbor] = newDist;
+    }
+  }
+
+  const maxDist = Math.max(...dist.slice(1));
+  return maxDist === Infinity ? -1 : maxDist;
+};
diff --git a/berrnuda/11week/7_Reverse_Integer.js b/berrnuda/11week/7_Reverse_Integer.js
new file mode 100644
index 0000000..72ce53d
--- /dev/null
+++ b/berrnuda/11week/7_Reverse_Integer.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number} x
+ * @return {number}
+ */
+var reverse = function (x) {
+  const sign = x < 0;
+  const rev = parseInt(String(Math.abs(x)).split("").reverse().join(""));
+
+  if (rev < -Math.pow(2, 31) || rev > Math.pow(2, 31) - 1) return 0;
+
+  return sign ? -rev : rev;
+};
diff --git a/berrnuda/1week/121_Best_Time_to_Buy_and_Sell_Stock.js b/berrnuda/1week/121_Best_Time_to_Buy_and_Sell_Stock.js
new file mode 100644
index 0000000..b3b3d53
--- /dev/null
+++ b/berrnuda/1week/121_Best_Time_to_Buy_and_Sell_Stock.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  const { length } = prices;
+  let minPrice = Math.max(...prices);
+  let maxProfit = 0;
+
+  for (let i = 0; i < length; i++) {
+    if (prices[i] < minPrice) {
+      minPrice = prices[i];
+    } else {
+      let profit = prices[i] - minPrice;
+      maxProfit = profit > maxProfit ? profit : maxProfit;
+    }
+  }
+  return maxProfit;
+};
diff --git a/berrnuda/1week/15_3Sum.js b/berrnuda/1week/15_3Sum.js
new file mode 100644
index 0000000..8668981
--- /dev/null
+++ b/berrnuda/1week/15_3Sum.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+  const { length } = nums;
+  const result = [];
+  const sortedNums = nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < length - 2; i++) {
+    if (i != 0 && sortedNums[i] === sortedNums[i - 1]) continue;
+
+    for (let j = i + 1, k = length - 1; j < k; ) {
+      const sum = sortedNums[i] + sortedNums[j] + sortedNums[k];
+
+      if (sum === 0) {
+        result.push([sortedNums[i], sortedNums[j], sortedNums[k]]);
+
+        while (j < k && sortedNums[j] === sortedNums[j + 1]) j++;
+        while (j < k && sortedNums[k] === sortedNums[k - 1]) k--;
+
+        j++;
+        k--;
+      } else if (sum < 0) {
+        j++;
+      } else {
+        k--;
+      }
+    }
+  }
+
+  return result;
+};
diff --git a/berrnuda/1week/217_Contains_Duplicate.js b/berrnuda/1week/217_Contains_Duplicate.js
new file mode 100644
index 0000000..4653506
--- /dev/null
+++ b/berrnuda/1week/217_Contains_Duplicate.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const { length } = nums;
+  const num = {};
+
+  for (let i = 0; i < length; i++) {
+    if (num[nums[i]]) return true;
+    num[nums[i]] = true;
+  }
+
+  return false;
+};
diff --git a/berrnuda/1week/252_Meeting_Rooms.js b/berrnuda/1week/252_Meeting_Rooms.js
new file mode 100644
index 0000000..d172279
--- /dev/null
+++ b/berrnuda/1week/252_Meeting_Rooms.js
@@ -0,0 +1,28 @@
+/**
+ * Definition of Interval:
+ * class Interval {
+ *   constructor(start, end) {
+ *     this.start = start;
+ *     this.end = end;
+ *   }
+ * }
+ */
+
+class Solution {
+  /**
+   * @param {Interval[]} intervals
+   * @returns {boolean}
+   */
+  canAttendMeetings(intervals) {
+    const sortedTimes = intervals.sort((a, b) => a.start - b.start);
+
+    let prevEnd = 0;
+
+    for (const interval of sortedTimes) {
+      if (interval.start < prevEnd) return false;
+      prevEnd = interval.end;
+    }
+
+    return true;
+  }
+}
diff --git a/berrnuda/1week/268_Missing_Number.js b/berrnuda/1week/268_Missing_Number.js
new file mode 100644
index 0000000..105e007
--- /dev/null
+++ b/berrnuda/1week/268_Missing_Number.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function (nums) {
+  const { length } = nums;
+  const sortedNums = nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < length; i++) {
+    if (sortedNums[i] !== i) return i;
+  }
+
+  return length;
+};
diff --git a/berrnuda/2week/100_Same_Tree.js b/berrnuda/2week/100_Same_Tree.js
new file mode 100644
index 0000000..554302f
--- /dev/null
+++ b/berrnuda/2week/100_Same_Tree.js
@@ -0,0 +1,26 @@
+/**
+ * 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} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+var isSameTree = function (p, q) {
+  if (p === null && q === null) return true;
+  if (p === null || q === null) return false;
+
+  if (p.val !== q.val) return false;
+
+  return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+};
+
+// Runtime:  53 ms    Beats 54.81%
+// Memory:   49.98 MB Beats 5.64%
+
+// 22m 38s
diff --git a/berrnuda/2week/191_number_of_1_bits.js b/berrnuda/2week/191_number_of_1_bits.js
new file mode 100644
index 0000000..75695a2
--- /dev/null
+++ b/berrnuda/2week/191_number_of_1_bits.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var hammingWeight1 = function (n) {
+  return n.toString(2).split("1").length - 1;
+  // n = 12 (1100) [1,1,00]
+  // n = 11 (1011) [1,0,1,1]
+};
+
+// Runtime:  57 ms    Beats 57.79%
+// Memory:   49.50 MB Beats 43.02%
+// 27s
+
+var hammingWeight2 = function (n) {
+  let i = 0;
+  for (; n != 0; i++) {
+    // n이 0이 될때까지 ( 1이 없을때까지 )
+    n &= n - 1; // n의 가장 오른쪽 1을 제거 후 and 연산으로 1만 남김
+    // n = 12 (1100), n - 1 = 11 (1011) n &= n - 1 = 1000
+  }
+  return i;
+};
+
+// Runtime:  43 ms    Beats 98.38%
+// Memory:   49.26 MB Beats 64.39%
+// 13m
diff --git a/berrnuda/2week/238_product_of_array_except_self.js b/berrnuda/2week/238_product_of_array_except_self.js
new file mode 100644
index 0000000..e5129b0
--- /dev/null
+++ b/berrnuda/2week/238_product_of_array_except_self.js
@@ -0,0 +1,43 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  const result = new Array(nums.length).fill(1);
+
+  // for (let i = 0; i < nums.length; i++) {
+  //     for (let j = 0; j < nums.length; j++) {
+  //         if (i !== j) result[i] *= nums[j];
+  //     }
+  // }
+
+  // return result;
+
+  // let leftNum = 1, rightNum = 1;
+
+  // for (let i = 0; i < nums.length; i++) {
+  //     result[i] = leftNum;
+  //     leftNum *= nums[i];
+  // }
+
+  for (let i = 1; i < nums.length; i++) {
+    result[i] = result[i - 1] * nums[i - 1];
+  }
+
+  let rightNum = 1;
+
+  for (let i = nums.length - 1; i >= 0; i--) {
+    result[i] *= rightNum;
+    rightNum *= nums[i];
+  }
+
+  return result;
+};
+
+// Runtime:  104 ms   Beats 57.07%
+// Memory:   66.98 MB Beats 14.99%
+
+// Runtime:  100 ms   Beats 69.84%
+// Memory:   64.41 MB Beats 53.44%
+
+// 21:22
diff --git a/berrnuda/2week/242_valid_anagram.js b/berrnuda/2week/242_valid_anagram.js
new file mode 100644
index 0000000..fef267f
--- /dev/null
+++ b/berrnuda/2week/242_valid_anagram.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function (s, t) {
+  // const sortS = s.split('').sort().join('');
+  // const sortT = t.split('').sort().join('');
+  // return sortS === sortT;
+  if (s.length !== t.length) return false;
+
+  const count = {};
+
+  for (let i = 0; i < s.length; i++) {
+    count[s[i]] ? count[s[i]]++ : (count[s[i]] = 1);
+  }
+
+  for (let i = 0; i < t.length; i++) {
+    if (!count[t[i]]) return false;
+    count[t[i]]--;
+  }
+
+  return true;
+};
+
+// Runtime:  86 ms    Beats 15.71%
+// Memory:   54.31 MB Beats 21.25%
+
+// Runtime:  68 ms    Beats 67.23%
+// Memory:   51.01 MB Beats 83.44%
+
+// 02:50
diff --git a/berrnuda/2week/746_Min_Cost_Climbing_Stairs.js b/berrnuda/2week/746_Min_Cost_Climbing_Stairs.js
new file mode 100644
index 0000000..f656ae8
--- /dev/null
+++ b/berrnuda/2week/746_Min_Cost_Climbing_Stairs.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[]} cost
+ * @return {number}
+ */
+var minCostClimbingStairs1 = function (cost) {
+  const memo = {};
+
+  const findMinCost = (i) => {
+    if (i <= 1) return 0;
+    if (memo[i] !== undefined) return memo[i];
+
+    memo[i] = Math.min(
+      findMinCost(i - 1) + cost[i - 1],
+      findMinCost(i - 2) + cost[i - 2]
+    );
+    return memo[i];
+  };
+
+  return findMinCost(cost.length);
+};
+
+// Runtime:  54 ms    Beats 69.10%
+// Memory:   50.97 MB Beats 16.89%
+
+// 17m 1s
+
+var minCostClimbingStairs2 = function (cost) {
+  for (let i = cost.length - 3; i >= 0; i--) {
+    cost[i] += Math.min(cost[i + 1], cost[i + 2]);
+  }
+
+  return Math.min(cost[0], cost[1]);
+};
+
+// Runtime:  60 ms    Beats 37.88%
+// Memory:   49.24 MB Beats 86.98%
+
+// 24m
diff --git a/berrnuda/3week/125_Valid_Palindrome.js b/berrnuda/3week/125_Valid_Palindrome.js
new file mode 100644
index 0000000..1573699
--- /dev/null
+++ b/berrnuda/3week/125_Valid_Palindrome.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function (s) {
+  s = s.toLowerCase().replace(/[^a-z0-9]/g, "");
+
+  let left = 0;
+  let right = s.length - 1;
+
+  for (; left < right; left++, right--) {
+    if (s[left] !== s[right]) return false;
+  }
+
+  return true;
+};
+
+// Runtime:  57 ms    Beats 83.28%
+// Memory:   51.20 MB Beats 90.34%
+
+// 4m 11s
diff --git a/berrnuda/3week/190_Reverse_Bits.js b/berrnuda/3week/190_Reverse_Bits.js
new file mode 100644
index 0000000..55aed40
--- /dev/null
+++ b/berrnuda/3week/190_Reverse_Bits.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ */
+var reverseBits = function (n) {
+  let result = 0;
+
+  for (let i = 0; i < 32; i++) {
+    result = (result << 1) | (n & 1);
+    n >>>= 1;
+  }
+
+  return result >>> 0;
+};
+
+// Runtime:  63 ms    Beats 36.23%
+// Memory:   50.85 MB Beats 67.17%
+
+// 7m 36s
diff --git a/berrnuda/3week/206_Reverse_Linked_list.js b/berrnuda/3week/206_Reverse_Linked_list.js
new file mode 100644
index 0000000..6ce45ae
--- /dev/null
+++ b/berrnuda/3week/206_Reverse_Linked_list.js
@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var reverseList = function (head) {
+  if (head === null || head.next === null) return head;
+
+  let nextHead = reverseList(head.next);
+
+  head.next.next = head;
+
+  head.next = null;
+
+  return nextHead;
+};
+
+// Runtime:  58 ms    Beats 65.93%
+// Memory:   52.49 MB Beats  8.56%
+
+// 12m 25s
diff --git a/berrnuda/3week/322_Coin_Change.js b/berrnuda/3week/322_Coin_Change.js
new file mode 100644
index 0000000..c06cc76
--- /dev/null
+++ b/berrnuda/3week/322_Coin_Change.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ */
+var coinChange = function (coins, amount) {
+  // let count = 0;
+  // coins = coins.sort((a, b) => b - a);
+
+  // for (let i = 0; i < coins.length; i++) {
+  //   if (amount >= coins[i]) {
+  //     count += Math.floor(amount / coins[i])
+  //     amount = amount % coins[i]
+  //   }
+
+  //   if (amount === 0) return count;
+  // }
+
+  // return -1;
+
+  const dp = new Array(amount + 1).fill(Infinity);
+  dp[0] = 0;
+
+  for (let i = 1; i <= amount; i++) {
+    for (let j = 0; j < coins.length; j++) {
+      if (i - coins[j] >= 0) dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
+    }
+  }
+
+  return dp[amount] === Infinity ? -1 : dp[amount];
+};
+
+// Runtime:  100 ms   Beats 58.10%
+// Memory:   54.62 MB Beats 68.70%
+
+// 10m 52s
diff --git a/berrnuda/3week/49_Group_Anagrams.js b/berrnuda/3week/49_Group_Anagrams.js
new file mode 100644
index 0000000..347ca29
--- /dev/null
+++ b/berrnuda/3week/49_Group_Anagrams.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string[]} strs
+ * @return {string[][]}
+ */
+var groupAnagrams = function (strs) {
+  const map = new Map();
+
+  for (let i = 0; i < strs.length; i++) {
+    const str = strs[i];
+    const sortStr = str.split("").sort().join("");
+
+    if (!map.has(sortStr)) map.set(sortStr, []);
+    map.get(sortStr).push(str);
+  }
+
+  return Array.from(map.values());
+};
+
+// Runtime:  112 ms   Beats 68.50%
+// Memory:   63.16 MB Beats 50.94%
+
+// 13m 48s
diff --git a/berrnuda/5week/1046_Last_Stone_Weight.js b/berrnuda/5week/1046_Last_Stone_Weight.js
new file mode 100644
index 0000000..15a4c45
--- /dev/null
+++ b/berrnuda/5week/1046_Last_Stone_Weight.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} stones
+ * @return {number}
+ */
+var lastStoneWeight = function (stones) {
+  for (; stones.length > 1; ) {
+    stones.sort((a, b) => b - a);
+
+    let first = stones[0];
+    let second = stones[1];
+
+    stones.splice(0, 2);
+
+    if (first !== second) {
+      stones.push(first - second);
+    }
+  }
+
+  return stones.length === 0 ? 0 : stones[0];
+};
+
+// Memory:   50.41 MB Beats 76.77%
+
+// 8m 2s
diff --git a/berrnuda/5week/21_Merge_Two_Sorted_Lists.js b/berrnuda/5week/21_Merge_Two_Sorted_Lists.js
new file mode 100644
index 0000000..7a93516
--- /dev/null
+++ b/berrnuda/5week/21_Merge_Two_Sorted_Lists.js
@@ -0,0 +1,55 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} list1
+ * @param {ListNode} list2
+ * @return {ListNode}
+ */
+var mergeTwoLists = function (list1, list2) {
+  let head = null;
+  let current = null;
+
+  for (; list1 !== null && list2 !== null; ) {
+    let selectedNode;
+
+    if (list1.val <= list2.val) {
+      selectedNode = list1;
+      list1 = list1.next;
+    } else {
+      selectedNode = list2;
+      list2 = list2.next;
+    }
+
+    if (head === null) {
+      head = selectedNode;
+      current = head;
+    } else {
+      current.next = selectedNode;
+      current = current.next;
+    }
+  }
+
+  if (list1 !== null) {
+    if (current === null) {
+      return list1;
+    }
+    current.next = list1;
+  } else if (list2 !== null) {
+    if (current === null) {
+      return list2;
+    }
+    current.next = list2;
+  }
+
+  return head;
+};
+
+// Runtime:  1 ms     Beats 97.72%
+// Memory:   51.30 MB Beats 82.63%
+
+// 5m 28s
diff --git a/berrnuda/5week/338_Counting_Bits.js b/berrnuda/5week/338_Counting_Bits.js
new file mode 100644
index 0000000..6658d3a
--- /dev/null
+++ b/berrnuda/5week/338_Counting_Bits.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+var countBits = function (n) {
+  const result = new Array(n + 1).fill(0);
+
+  for (let i = 1; i <= n; i++) {
+    result[i] = result[i >> 1] + (i & 1);
+  }
+
+  return result;
+};
+
+// Runtime:  1 ms     Beats 99.45%
+// Memory:   56.49 MB Beats 52.28%
+
+// 14m 28s
diff --git a/berrnuda/5week/48_Rotate_Image.js b/berrnuda/5week/48_Rotate_Image.js
new file mode 100644
index 0000000..0bad776
--- /dev/null
+++ b/berrnuda/5week/48_Rotate_Image.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[][]} matrix
+ * @return {void} Do not return anything, modify matrix in-place instead.
+ */
+var rotate = function (matrix) {
+  const n = matrix.length;
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
+    }
+  }
+
+  for (let i = 0; i < n; i++) {
+    matrix[i].reverse();
+  }
+};
+
+// Memory:   50.26 MB Beats 30.78%
+
+// 15m 42s
diff --git a/berrnuda/5week/70_Climbing_Stairs.js b/berrnuda/5week/70_Climbing_Stairs.js
new file mode 100644
index 0000000..c3fefca
--- /dev/null
+++ b/berrnuda/5week/70_Climbing_Stairs.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+  // dp[i] = dp[i-1] + dp[i-2]
+  if (n <= 2) return n;
+
+  let dp1 = 1;
+  let dp2 = 2;
+
+  for (let i = 3; i <= n; i++) {
+    let temp = dp1 + dp2;
+    dp1 = dp2;
+    dp2 = temp;
+  }
+
+  return dp2;
+};
+
+// Runtime:  0 ms     Beats 100.00%
+// Memory:   48.76 MB Beats 52.62%
+
+// 3m 11s
diff --git a/berrnuda/6week/198_House_Robber.js b/berrnuda/6week/198_House_Robber.js
new file mode 100644
index 0000000..3ca4ee1
--- /dev/null
+++ b/berrnuda/6week/198_House_Robber.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  let rob1 = 0;
+  let rob2 = 0;
+
+  for (let i = 0; i < nums.length; i++) {
+    let rob = Math.max(rob2 + nums[i], rob1);
+    rob2 = rob1;
+    rob1 = rob;
+  }
+
+  return rob1;
+};
diff --git a/berrnuda/6week/271_Encode_and_Decode_Strings.js b/berrnuda/6week/271_Encode_and_Decode_Strings.js
new file mode 100644
index 0000000..4028acc
--- /dev/null
+++ b/berrnuda/6week/271_Encode_and_Decode_Strings.js
@@ -0,0 +1,35 @@
+class Solution {
+  /**
+   * @param {string[]} strs
+   * @returns {string}
+   */
+  encode(strs) {
+    let encodedStr = "";
+
+    for (let i = 0; i < strs.length; i++) {
+      encodedStr += strs[i] + "[" + strs[i].length + "]";
+    }
+
+    return encodedStr;
+  }
+
+  /**
+   * @param {string} str
+   * @returns {string[]}
+   */
+  decode(str) {
+    let decodedStrs = [];
+
+    for (let i = 0; i < str.length; ) {
+      let firstIndex = str.indexOf("[", i);
+      let lastIndex = str.indexOf("]", firstIndex);
+
+      let word = str.substring(i, firstIndex);
+      decodedStrs.push(word);
+
+      i = lastIndex + 1;
+    }
+
+    return decodedStrs;
+  }
+}
diff --git a/berrnuda/6week/66_Plus_One.js b/berrnuda/6week/66_Plus_One.js
new file mode 100644
index 0000000..cb0eb59
--- /dev/null
+++ b/berrnuda/6week/66_Plus_One.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} digits
+ * @return {number[]}
+ */
+var plusOne = function (digits) {
+  let l = digits.length;
+
+  for (let i = l - 1; i >= 0; i--) {
+    digits[i]++;
+    if (digits[i] == 10) digits[i] = 0;
+    else return digits;
+  }
+
+  digits.unshift(1);
+
+  return digits;
+};
diff --git a/berrnuda/6week/703_Kth_Largest_Element_in_a_Stream.js b/berrnuda/6week/703_Kth_Largest_Element_in_a_Stream.js
new file mode 100644
index 0000000..1ab1c05
--- /dev/null
+++ b/berrnuda/6week/703_Kth_Largest_Element_in_a_Stream.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number} k
+ * @param {number[]} nums
+ */
+var KthLargest = function (k, nums) {
+  this.k = k;
+  this.score = [];
+
+  for (let num of nums) this.add(num);
+};
+
+/**
+ * @param {number} val
+ * @return {number}
+ */
+KthLargest.prototype.add = function (val) {
+  if (this.score.length < this.k) this.score.push(val);
+  else if (val > this.score[this.k - 1]) this.score[this.k - 1] = val;
+
+  this.score.sort((a, b) => b - a);
+
+  return this.score[this.k - 1];
+};
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * var obj = new KthLargest(k, nums)
+ * var param_1 = obj.add(val)
+ */
diff --git a/berrnuda/6week/704_Binary_Search.js b/berrnuda/6week/704_Binary_Search.js
new file mode 100644
index 0000000..7e8c49b
--- /dev/null
+++ b/berrnuda/6week/704_Binary_Search.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function (nums, target) {
+  let first = 0;
+  let last = nums.length - 1;
+
+  for (; first <= last; ) {
+    let curr = Math.floor((first + last) / 2);
+
+    if (nums[curr] === target) return curr;
+    else if (nums[curr] < target) first = curr + 1;
+    else last = curr - 1;
+  }
+
+  return -1;
+};
diff --git a/berrnuda/9week/102_Binary_Tree_Level_Order_Traversal.js b/berrnuda/9week/102_Binary_Tree_Level_Order_Traversal.js
new file mode 100644
index 0000000..6596f35
--- /dev/null
+++ b/berrnuda/9week/102_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[][]}
+ */
+var levelOrder = function (root) {
+  if (!root) return [];
+
+  let result = [];
+  let queue = [root];
+  let start = 0;
+
+  for (; start < queue.length; ) {
+    let level = queue.length - start;
+    let curLevel = [];
+
+    for (let i = 0; i < level; i++) {
+      let curNode = queue[start++];
+      curLevel.push(curNode.val);
+
+      if (curNode.left) queue.push(curNode.left);
+      if (curNode.right) queue.push(curNode.right);
+    }
+
+    result.push(curLevel);
+  }
+
+  return result;
+};
diff --git a/berrnuda/9week/150_Evaluate_Reverse_Polish_Notation.js b/berrnuda/9week/150_Evaluate_Reverse_Polish_Notation.js
new file mode 100644
index 0000000..b371571
--- /dev/null
+++ b/berrnuda/9week/150_Evaluate_Reverse_Polish_Notation.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string[]} tokens
+ * @return {number}
+ */
+var evalRPN = function (tokens) {
+  const stack = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    if (["+", "-", "*", "/"].includes(tokens[i])) {
+      const second = stack.pop();
+      const first = stack.pop();
+
+      const result = eval(`${first} ${tokens[i]} ${second}`);
+      stack.push(Math.trunc(result));
+    } else {
+      stack.push(Number(tokens[i]));
+    }
+  }
+
+  return stack[0];
+};
diff --git a/berrnuda/9week/213_House_Robber_II.js b/berrnuda/9week/213_House_Robber_II.js
new file mode 100644
index 0000000..ac30b4e
--- /dev/null
+++ b/berrnuda/9week/213_House_Robber_II.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  if (nums.length === 1) return nums[0];
+  if (nums.length === 2) return Math.max(nums[0], nums[1]);
+
+  const robRange = (start, end) => {
+    let prev1 = 0;
+    let prev2 = 0;
+
+    for (let i = start; i <= end; i++) {
+      let temp = Math.max(prev1, prev2 + nums[i]);
+      prev2 = prev1;
+      prev1 = temp;
+    }
+
+    return prev1;
+  };
+
+  return Math.max(robRange(0, nums.length - 2), robRange(1, nums.length - 1));
+};
diff --git a/berrnuda/9week/572_Subtree_of_Another_Tree.js b/berrnuda/9week/572_Subtree_of_Another_Tree.js
new file mode 100644
index 0000000..804906b
--- /dev/null
+++ b/berrnuda/9week/572_Subtree_of_Another_Tree.js
@@ -0,0 +1,29 @@
+/**
+ * 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
+ * @param {TreeNode} subRoot
+ * @return {boolean}
+ */
+var isSubtree = function (root, subRoot) {
+  if (!root || !subRoot) return false;
+
+  const isSame = (t1, t2) => {
+    if (!t1 && !t2) return true;
+    if (!t1 || !t2 || t1.val !== t2.val) return false;
+
+    return isSame(t1.left, t2.left) && isSame(t1.right, t2.right);
+  };
+
+  return (
+    isSame(root, subRoot) ||
+    isSubtree(root.left, subRoot) ||
+    isSubtree(root.right, subRoot)
+  );
+};