js-concepts: leetcode binary search problems

Author: baochau.dinh

Design Patterns/Singleton/customer.js

@@ -0,0 +1,12 @@
+const FoodLogger = require('./singleton');
+const foodLogger = new FoodLogger().getFoodLogerInstance();
+
+class Customer {
+  constructor(order) {
+    this.price = order.price,
+    this.food = order.food,
+    foodLogger.log(order);
+  }
+}
+
+module.exports = Customer;

Design Patterns/Singleton/restaurant.js

@@ -0,0 +1,13 @@
+const FoodLogger = require('./singleton');
+
+const foodLogger = new FoodLogger().getFoodLogerInstance();
+
+class Restaurant {
+  constructor(inventory) {
+    this.quantity = inventory.quantity,
+    this.food = inventory.food,
+    foodLogger.log(inventory)
+  }
+}
+
+module.exports = Restaurant;

Design Patterns/Singleton/singleton.js

@@ -0,0 +1,30 @@
+/**
+ * The singleton pattern helps us build the logs from the application
+ * We can get them anywhere in our code base with exact the same instance
+ * of the logger.
+ */
+
+class FoodLogger {
+  constructor() {
+    this.foodLog = [];
+  }
+  
+  log(order) {
+    this.foodLog.push(order.foodItem);
+  }
+}
+
+// this is singleton
+class FoodLoggerSingleton {
+  constructor() {
+    if (!FoodLoggerSingleton.instance) {
+      FoodLoggerSingleton.instance = new FoodLogger();
+    }
+  }
+
+  getFoodLogerInstance() {
+    return FoodLoggerSingleton.instance;
+  }
+}
+
+module.exports = FoodLoggerSingleton;

Design Patterns/Strategy/config.json

@@ -0,0 +1,5 @@
+{
+  "paymentMethod": {
+    "strategy": "Paypal"
+  }
+}

Design Patterns/Strategy/strategy.ts

@@ -0,0 +1,37 @@
+/**
+ * The strategy pattern is like an advanced version of if-else statement
+ */
+
+interface CustomerInfoType {
+  country: string
+  emailAddress: string
+  name: string
+  accountNumber?: number
+  address?: string
+  cardNumber?: number
+  city?: string
+  routingNumber?: number
+  state?: string
+}
+
+export default class PaymentMethodStrategy {
+  static BankAccount(customerInfo: CustomerInfoType) {
+    const {name, accountNumber, routingNumber} = customerInfo;
+  }
+
+  static BitCoin(customerInfo: CustomerInfoType) {
+    const {emailAddress, accountNumber} = customerInfo;
+  }
+
+  static CreditCard(customerInfo: CustomerInfoType) {
+    const {name, cardNumber, emailAddress} = customerInfo;
+  }
+
+  static MailIn(customerInfo: CustomerInfoType) {
+    const {name, address, city, state} = customerInfo;
+  }
+
+  static Paypal(customerInfo: CustomerInfoType) {
+    const {emailAddress} = customerInfo;
+  }
+}

LeetCode/21. Merge Two Sorted Lists/index.js

@@ -0,0 +1,35 @@
+function ListNode(val, next) {
+  this.val = (val === undefined ? 0 : val);
+  this.next = (next === undefined ? null : next);
+}
+
+function mergeTwoList (list1, list2) {
+  let head = new ListNode();
+  let curr = head;
+
+  let curr1 = list1, curr2 = list2;
+  while (curr1 !== null && curr2 !== null) {
+    if (curr1.val < curr2.val) {
+      curr.next = curr1;
+      curr1 = curr1.next;
+    } else {
+      curr.next = curr2;
+      curr2 = curr2.next;
+    }
+    curr = curr.next;
+  }
+
+  if (curr1 !== null) {
+    curr.next = curr1;
+  }
+
+  if (curr2 !== null) {
+    curr.next = curr2;
+  }
+
+  return head.next;
+}
+
+let list1 = new ListNode()
+
+console.log(mergeTwoList())

LeetCode/33. Search in Rotated Sorted Array/index.js

@@ -0,0 +1,52 @@
+const binarySearch = function (nums, target) {
+  let left = 0, right = nums.length - 1;
+  while (left <= right) {
+    let mid = left + Math.floor((right - left) / 2);
+    if (nums[mid] === target) {
+      return mid;
+    } else if (nums[mid] < target) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+  return -1;
+}
+
+const detectShift = function (nums) {
+  let left = 0, right = nums.length - 1;
+  let ans = 0;
+  while (left < right) {
+    let mid = left + Math.floor((right - left) / 2);
+    if (nums[mid] > nums[left]) {
+      ans = mid;
+      left = mid;
+    } else {
+      right = mid;
+    }
+  }
+  return ans;
+}
+
+const search = function (nums, target) {
+  let shiftIndx = detectShift(nums);
+  let result = -1;
+  if (nums[shiftIndx] === target) {
+    return shiftIndx;
+  }
+  let first = binarySearch(nums.slice(0, shiftIndx + 1), target);
+  let second = binarySearch(nums.slice(shiftIndx + 1, nums.length), target);
+  
+  if (first === -1 && second === -1) {
+    return result;
+  } else {
+    if (first !== -1) {
+      return first;
+    }
+    if (second !== -1) {
+      return shiftIndx + second + 1;
+    }
+  }
+}
+
+console.log(search([4, 5, 6, 7, 0, 1, 2], 2));

LeetCode/Remove duplicate numbers/index.js

@@ -0,0 +1,56 @@
+/**
+ * Remove duplicates from sorted array
+ * 
+ * return the length
+ */
+
+function removeDuplicates(nums = []) {
+  if (nums.length === 0) return 0;
+  let first = 0, second = 1;
+  while (first < nums.length && second < nums.length) {
+    if (nums[first] !== nums[second]) {
+      first = second;
+      second++;
+    } else {
+      nums.splice(second, 1);
+    }
+  }
+
+  return nums.length;
+}
+
+function removeDuplicatesV2(nums = []) {
+  let frequenceMap = {};
+  let result = [];
+
+  for (let i = 0; i < nums.length; i++) {
+    frequenceMap[nums[i]] = frequenceMap[nums[i]] ? frequenceMap[nums[i]] + 1 : 1
+  }
+
+  for (key in frequenceMap) {
+    result.push(parseInt(key));
+  }
+
+  return result;
+}
+
+console.log(removeDuplicatesV2([1, 1, 2]));
+
+/**
+ * 
+ * 
+ * 
+ * 2 3 6 7 9 15 19
+ * 
+ * 6 7 9 15 19 2 3
+ * target = 2
+ * nums[mid] = 15
+ * 
+ * 
+ * 9 15 19 2 3 6 7
+ * 
+ * 15 19 2 3 6 7 9
+ * target = 19
+ * nums[mid] = 3
+ * nums[mid] < target && nums[left] < target
+ */