arrays

Author: bombay21

averagePair.js

@@ -0,0 +1,13 @@
+function averagePair(arr, num) {
+  let start = 0;
+  let end = arr.length - 1;
+  while (start < end) {
+    let avg = (arr[start] + arr[end]) / 2;
+    if (avg === num) return true;
+    else if (avg < num) start++;
+    else end--;
+  }
+  return false;
+}
+
+console.log(averagePair([2,6,7,8,1,5],4))

countUniqueValues.js

@@ -0,0 +1,26 @@
+let countUniqueValues = (arr) => {
+    // arr is sorted
+    let count = 0
+    
+    if (arr.length == 0) {
+      // return 0 if array is empty
+      count = 0;
+    } else if (arr.length == 1){
+      // return 1 if there's only 1 item in the array
+      count = 1;
+    } else {
+        count = 1
+        let left = 0,
+        right = arr.length - 1;
+
+        while (arr[left] < arr[right]) {
+        if (arr[left] < arr[left + 1]) count++;
+        left++;
+        }
+    }
+    
+    console.log(count)
+    return count
+}
+
+countUniqueValues([-2,-2,0])

duplicateChecker.js

@@ -0,0 +1,42 @@
+// using frequency counter
+function areThereDuplicates() {
+  let collection = {};
+  for (let val in arguments) {
+    collection[arguments[val]] = (collection[arguments[val]] || 0) + 1;
+  }
+  console.log(collection)
+  for (let key in collection) {
+    if (collection[key] > 1) return true;
+  }
+  return false;
+}
+
+console.log("using frequency counter: "+areThereDuplicates(1,5,6,6,3,4,9));
+
+// using multiple pointers
+function areThereDuplicates(...args) {
+  // Two pointers
+  args.sort((a, b) => a > b);
+  let start = 0;
+  let next = 1;
+  while (next < args.length) {
+    if (args[start] === args[next]) {
+      return true;
+    }
+    start++;
+    next++;
+  }
+  return false;
+}
+
+console.log(
+  "using multiple pointers: " + areThereDuplicates(1, 5, 6, 3, 4, 9)
+);
+
+// using one liner solution
+function areThereDuplicates() {
+  return new Set(arguments).size !== arguments.length;
+}
+console.log(
+  "using one liner solution: " + areThereDuplicates(1, 5, 6, 6, 3, 4, 9)
+);

longestSubString.js

@@ -0,0 +1,23 @@
+
+//   Write a function called findLongestSubstring, which accepts a string
+//   and returns the length of the longest substring with all distinct characters.
+
+function findLongestSubstring(str) {
+  let longest = 0;
+  let seen = {};
+  let start = 0;
+
+  for (let i = 0; i < str.length; i++) {
+    let char = str[i];
+    if (seen[char]) {
+      start = Math.max(start, seen[char]);
+    }
+    // index - beginning of substring + 1 (to include current in count)
+    longest = Math.max(longest, i - start + 1);
+    // store the index of the next char so as to not double count
+    seen[char] = i + 1;
+  }
+  return longest;
+}
+
+console.log(findLongestSubstring("leech"));

maxSubArray.js

@@ -0,0 +1,17 @@
+let maxSubArray = (arr, n) => {
+    let maxSum = 0
+    let tempSum = 0
+    if(arr.length < n) return null
+    for(let i=0;i<n;i++){
+        maxSum += arr[i]
+    }
+    tempSum = maxSum
+    for(let i=n;i<arr.length;i++){
+        tempSum += arr[i] - arr[i - n];
+        maxSum=Math.max(maxSum,tempSum)
+    }
+    console.log(maxSum)
+    return maxSum
+}
+
+maxSubArray([2,4,7,1,4,5,9,1],1);

minSubArrLen.js

@@ -0,0 +1,37 @@
+// Write a function called minSubArrayLen which accepts two parameters -
+// an array of positive integers and a positive integer.
+
+// This function should return the minimal length of a contiguous subarray of which the sum is greater
+// than or equal to the integer passed to the function. If there isn't one, return 0 instead.Examples:
+
+function minSubArrayLen(nums, sum) {
+  let total = 0;
+  let start = 0;
+  let end = 0;
+  let minLen = Infinity;
+
+  while (start < nums.length) {
+    // if current window doesn't add up to the given sum then
+    // move the window to right
+    if (total < sum && end < nums.length) {
+      total += nums[end];
+      end++;
+    }
+    // if current window adds up to at least the sum given then
+    // we can shrink the window
+    else if (total >= sum) {
+      minLen = Math.min(minLen, end - start);
+      total -= nums[start];
+      start++;
+    }
+    // current total less than required total but we reach the end, need this or else we'll be in an infinite loop
+    else {
+      break;
+    }
+  }
+
+  return minLen === Infinity ? 0 : minLen;
+}
+
+console.log(minSubArrayLen([2, 3, 1, 2, 4, 3], 7));
+console.log(minSubArrayLen([2, 1, 6, 5, 4], 9));

sameFrequency.js

@@ -0,0 +1,25 @@
+function sameFrequency(num1, num2) {
+  let strNum1 = num1.toString();
+  let strNum2 = num2.toString();
+  if (strNum1.length !== strNum2.length) return false;
+
+  let countNum1 = {};
+  let countNum2 = {};
+
+  for (let i = 0; i < strNum1.length; i++) {
+    countNum1[strNum1[i]] = (countNum1[strNum1[i]] || 0) + 1;
+  }
+
+  for (let j = 0; j < strNum1.length; j++) {
+    countNum2[strNum2[j]] = (countNum2[strNum2[j]] || 0) + 1;
+  }
+
+  for (let key in countNum1) {
+    if (countNum1[key] !== countNum2[key]) return false;
+  }
+
+  return true;
+}
+
+console.log(sameFrequency("wrong", "grown"));
+console.log(sameFrequency("grab", "crab"));

subSequence.js

@@ -0,0 +1,25 @@
+
+// Iterative
+function isSubsequence(str1, str2) {
+  var i = 0;
+  var j = 0;
+  if (!str1) return true;
+  while (j < str2.length) {
+    if (str2[j] === str1[i]) i++;
+    if (i === str1.length) return true;
+    j++;
+  }
+  return false;
+}
+
+console.log("Iterative: "+isSubsequence("str1", "str2"));
+
+// Recursive but not O(1) Space
+function isSubsequence(str1, str2) {
+  if (str1.length === 0) return true;
+  if (str2.length === 0) return false;
+  if (str2[0] === str1[0]) return isSubsequence(str1.slice(1), str2.slice(1));
+  return isSubsequence(str1, str2.slice(1));
+}
+
+console.log("Recursive: "+isSubsequence("str1", "str2"));