fix types

Author: charliesbot

.github/workflows/ci.yml

@@ -30,6 +30,7 @@ const letterCombinations = function (digits: string) {
       return;
     }
 
+    // @ts-ignore
     const letters = numbers[digits[index]];
 
     for (let i = 0; i < letters.length; i++) {

typescript/0017_letter_combinations_of_a_phone_number/0017_letter_combinations_of_a_phone_number.ts

@@ -1,14 +1,5 @@
-class ListNode {
-  val: number;
-  next: ListNode | null;
-  constructor(val: number) {
-    this.val = val;
-    this.next = null;
-  }
-}
-
 const swapPairs = function (head: ListNode) {
-  let newHead = new ListNode(-1);
+  let newHead = new ListNode({ value: -1 });
   newHead.next = head;
   let current: ListNode | null = newHead;
   let stack: ListNode[] = [];

typescript/0024_swap_nodes_in_pairs/0024_swap_nodes_in_pairs.ts

@@ -2,13 +2,13 @@
  * Given an integer array nums,
  * find the contiguous subarray (containing at least one number)
  * which has the largest sum and return its sum.
-*/
+ */
 
 /**
  * @param {number[]} nums
  * @return {number}
  */
-var maxSubArray = function(nums) {
+var maxSubArray = function (nums: number[]) {
   let sum = 0;
   let max = -Infinity;
 

typescript/0053_maximum_subarray/0053_maximum_subarray.ts

@@ -6,7 +6,7 @@
  * You may assume the integer does not contain any leading zero, except the number 0 itself.
  */
 
-var plusOne = function(digits) {
+var plusOne = function (digits: number[]) {
   for (let i = digits.length - 1; i >= 0; i--) {
     digits[i] += 1;
 

typescript/0066_plus_one/0066_plus_one.ts

@@ -5,16 +5,16 @@
  * Note:
  * The same word in the dictionary may be reused multiple times in the segmentation.
  * You may assume the dictionary does not contain duplicate words.
-*/
+ */
 
 /**
  * @param {string} s
  * @param {string[]} wordDict
  * @return {boolean}
  */
-var wordBreak = function(s, wordDict) {
-  wordDict = new Set(wordDict);
-  isWordBreak = new Set().add(0);
+var wordBreak = function (s: string, wordDict: string[]) {
+  const wordSet = new Set(wordDict);
+  const isWordBreak = new Set().add(0);
 
   for (let i = 0; i < s.length + 1; i++) {
     for (let j = 0; j < i; j++) {
@@ -24,7 +24,7 @@ var wordBreak = function(s, wordDict) {
         continue;
       }
 
-      if (wordDict.has(s.substring(j, i))) {
+      if (wordSet.has(s.substring(j, i))) {
         isWordBreak.add(i);
         break;
       }

typescript/0139_word_break/0139_word_break.ts

@@ -2,97 +2,89 @@
  * @param {number} capacity
  */
 
-var Node = function(key, val) {
-  this.prev = null;
-  this.next = null;
-  this.val = val;
-  this.key = key;
-};
+class LRUCache {
+  capacity: number;
+  count: number;
+  head: ListNode;
+  tail: ListNode;
+  hash: { [key: string]: any };
 
-var LRUCache = function(capacity) {
-  this.capacity = capacity;
-  this.count = 0;
-  this.head = new Node(-1, -1);
-  this.tail = new Node(-1, -1);
-  this.head.next = this.tail;
-  this.tail.prev = this.head;
-  this.hash = {};
-};
-
-/**
- * @param {number} key
- * @return {number}
- */
-LRUCache.prototype.get = function(key) {
-  if (this.hash[key]) {
-    const currentNode = this.hash[key];
-    const tempPrev = currentNode.prev;
-    const tempNext = currentNode.next;
-    const tempPrevTail = this.tail.prev;
-    const tempPrevNext = this.tail.next;
-    tempPrev.next = tempNext;
-    tempNext.prev = tempPrev;
-    this.tail.prev.next = currentNode;
-    currentNode.prev = tempPrevTail;
-    currentNode.next = this.tail;
-    this.tail.prev = currentNode;
-    return this.hash[key].value;
+  constructor(capacity: number) {
+    this.capacity = capacity;
+    this.count = 0;
+    this.head = new ListNode({ key: -1, value: -1 });
+    this.tail = new ListNode({ key: -1, value: -1 });
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+    this.hash = {};
   }
 
-  return -1;
-};
+  get(key: number): number {
+    if (this.hash[key]) {
+      const currentNode = this.hash[key];
+      const tempPrev = currentNode.prev;
+      const tempNext = currentNode.next;
+      const tempPrevTail = this.tail.prev;
+      //const tempPrevNext = this.tail.next;
+      tempPrev.next = tempNext;
+      tempNext.prev = tempPrev;
+      //this.tail.prev.next = currentNode;
+      currentNode.prev = tempPrevTail;
+      currentNode.next = this.tail;
+      this.tail.prev = currentNode;
+      return this.hash[key].value;
+    }
 
-/**
- * @param {number} key
- * @param {number} value
- * @return {void}
- */
-LRUCache.prototype.put = function(key, value) {
-  let node = new Node(key, value);
-  if (this.hash[key]) {
-    node = this.tail.prev;
-    node.val = value;
-  } else if (this.count === this.capacity) {
-    const temp = this.head.next.next;
-    delete this.hash[this.head.next.key];
-    this.head.next = temp;
-    temp.prev = this.head;
-  } else {
-    this.count++;
+    return -1;
   }
-  const temp = this.tail.prev;
-  temp.next = node;
-  node.prev = temp;
-  node.next = this.tail;
-  this.tail.prev = node;
-  this.hash[key] = node;
-  this.print();
-};
 
-LRUCache.prototype.moveToHead = function() {};
+  // put(key: number, value: number) {
+  // let node = new ListNode({ key, value });
+  // if (this.hash[key]) {
+  // node = this.tail.prev;
+  // node.val = value;
+  // } else if (this.count === this.capacity) {
+  // const temp = this.head.next.next;
+  // delete this.hash[this.head.next.key];
+  // this.head.next = temp;
+  // temp.prev = this.head;
+  // } else {
+  // this.count++;
+  // }
+  // const temp = this.tail.prev;
+  // temp.next = node;
+  // node.prev = temp;
+  // node.next = this.tail;
+  // this.tail.prev = node;
+  // this.hash[key] = node;
+  // this.print();
+  // }
+}
 
-LRUCache.prototype.print = function(message = "") {
-  let currentNode = this.head;
-  console.log("---- init ---");
-  while (currentNode !== null) {
-    console.log(`${message}: [${currentNode.key}, ${currentNode.val}]`);
-    currentNode = currentNode.next;
-  }
-  console.log("---- end ---");
-};
+// LRUCache.prototype.moveToHead = function () {};
+
+// LRUCache.prototype.print = function (message = "") {
+// let currentNode = this.head;
+// console.log("---- init ---");
+// while (currentNode !== null) {
+// console.log(`${message}: [${currentNode.key}, ${currentNode.val}]`);
+// currentNode = currentNode.next;
+// }
+// console.log("---- end ---");
+// };
 /**
  * Your LRUCache object will be instantiated and called as such:
  * var obj = Object.create(LRUCache).createNew(capacity)
  * var param_1 = obj.get(key)
  * obj.put(key,value)
  */
 
-const cache = new LRUCache(2);
-cache.put(2, 1);
-cache.put(2, 2);
-cache.get(2);
-cache.put(4, 1);
-cache.put(1, 1);
-cache.get(2);
+// const cache = new LRUCache(2);
+// cache.put(2, 1);
+// cache.put(2, 2);
+// cache.get(2);
+// cache.put(4, 1);
+// cache.put(1, 1);
+// cache.get(2);
 // ["LRUCache","put","put","get","put","put","get"]
 // [[2],[2,1],[2,2],[2],[1,1],[4,1],[2]]

typescript/0146_lru_cache/0146_lru_cache.ts

@@ -1,45 +1,36 @@
 /**
  * initialize your data structure here.
  */
-var MinStack = function() {
-  this.stack = [];
-  this.mins = [];
-};
+class MinStack {
+  stack: number[];
+  mins: number[];
 
-/**
- * @param {number} x
- * @return {void}
- */
-MinStack.prototype.push = function(x) {
-  this.stack.push(x);
-  const min = this.getMin();
-  if (min === undefined || x <= min) {
-    this.mins.push(x);
+  constructor() {
+    this.stack = [];
+    this.mins = [];
   }
-};
 
-/**
- * @return {void}
- */
-MinStack.prototype.pop = function() {
-  const val = this.stack.pop();
-  const min = this.getMin();
+  push(x: number) {
+    this.stack.push(x);
+    const min = this.getMin();
+    if (min === undefined || x <= min) {
+      this.mins.push(x);
+    }
+  }
+  pop() {
+    const val = this.stack.pop();
+    const min = this.getMin();
 
-  if (min !== undefined && val <= min) {
-    this.mins.pop();
+    if (min !== undefined && val !== undefined && val <= min) {
+      this.mins.pop();
+    }
   }
-};
 
-/**
- * @return {number}
- */
-MinStack.prototype.top = function() {
-  return this.stack[this.stack.length - 1];
-};
+  top() {
+    return this.stack[this.stack.length - 1];
+  }
 
-/**
- * @return {number}
- */
-MinStack.prototype.getMin = function() {
-  return this.mins[this.mins.length - 1];
-};
+  getMin() {
+    return this.mins[this.mins.length - 1];
+  }
+}

typescript/0155_min_stack/0155_min_stack.ts

@@ -2,11 +2,11 @@
  * @param {number[]} nums
  * @return {number}
  */
-const rob = function(nums) {
+const rob = function (nums: number[]) {
   let inclusive = 0;
   let exclusive = 0;
 
-  nums.forEach(current => {
+  nums.forEach((current) => {
     let temp = inclusive;
     inclusive = Math.max(exclusive + current, inclusive);
     exclusive = temp;

typescript/0198_house_robber/0198_house_robber.ts

@@ -5,20 +5,15 @@
  * Example:
  * Input: nums = [3,5,2,1,6,4]
  * Output: One possible answer is [3,5,1,6,2,4]
-*/
-
-/**
- * @param {number[]} nums
- * @return {void} Do not return anything, modify nums in-place instead.
  */
 
-var swap = (nums, i) => {
+var swap = (nums: number[], i: number) => {
   nums[i] ^= nums[i + 1];
   nums[i + 1] ^= nums[i];
   nums[i] ^= nums[i + 1];
 };
 
-var wiggleSort = function(nums) {
+var wiggleSort = function (nums: number[]) {
   for (let i = 0; i < nums.length - 1; i++) {
     if (i % 2 === 0 && nums[i] > nums[i + 1]) {
       swap(nums, i);