Added:TypeScriptSolutions 153, 19, 238, 33

typescript/153-Find-Minimum-in-Rotated-Sorted-Array.ts

@@ -0,0 +1,13 @@
+function findMin(nums: number[]): number {
+  let left: number = 0
+  let right: number = nums.length - 1
+  while (right > left) {
+    let midIdx: number = Math.floor((left + right) / 2)
+    if (nums[midIdx] > nums[right]) {
+      left = midIdx + 1
+    } else {
+      right = midIdx
+    }
+  }
+  return nums[left]
+}

typescript/19-Remove-Nth-Node-From-End-of-List.ts

@@ -0,0 +1,35 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+  let dummyList: ListNode = new ListNode(0)
+  dummyList.next = head
+  let count: number = 0
+  let first: ListNode = dummyList
+  let second: ListNode = dummyList
+
+  while (count < n) {
+    second = second.next
+    count++
+  }
+  if (second === null) {
+    dummyList.val = dummyList.next.val
+    dummyList.next = dummyList.next.next
+  }
+  while (second.next !== null) {
+    second = second.next
+    first = first.next
+  }
+  first.next = first.next.next
+
+  return dummyList.next
+}

typescript/238-Product-of-Array-Except-Self.ts

@@ -0,0 +1,18 @@
+function productExceptSelf(nums: number[]): number[] {
+  const array: Array<number> = []
+  let product: number = 1
+
+  for (let idx = 0; idx < nums.length; idx++) {
+    array[idx] = product
+    product *= nums[idx]
+  }
+
+  product = 1
+
+  for (let idx = nums.length - 1; idx >= 0; idx--) {
+    array[idx] *= product
+    product *= nums[idx]
+  }
+
+  return array
+}

typescript/33-Search-in-Rotated-Sorted-Array.ts

@@ -0,0 +1,18 @@
+function search(nums: number[], target: number): number {
+  let left: number = 0
+  let right: number = nums.length - 1
+
+  while (left <= right) {
+    let midIdx: number = Math.floor((left + right) / 2)
+    if (nums[midIdx] === target) return midIdx
+
+    if (nums[left] <= nums[midIdx]) {
+      if (nums[left] <= target && target <= nums[midIdx]) right = midIdx - 1
+      else left = midIdx + 1
+    } else {
+      if (nums[midIdx] <= target && target <= nums[right]) left = midIdx + 1
+      else right = midIdx - 1
+    }
+  }
+  return -1
+}