helpful-fnc.js

// iterative
var topView = (head) => {
  if (!head)
    return false

  let left = [];
  let center = head.value
  let right  =[]

  while (!head.left && !head.right) {
    left.push(head.left);
    right.push(head.right);
    head.left = head.left;
    head.right = head.right;
  }

  return left.concat(middle).concat(right);
}

// iterative
var reverseList = (head) => {
  let pre = null;
  while (head) {
    // save next before overwrite
    const next = head.next;
    // set pre
    head.next = pre;
    pre = head;
    head = next;
  }
  return pre;
}

// recursive
var reverseList = (head) => {
  if (!head || !head.next)
    return head
  let tmp = reverseList(head.next)
  head.next.next = head;
  head.next = undefined;
  return tmp;
}

// iterative
var isSameList = (headA, headB) => {
  while (headA !== null && headB !== null) {
    if (headA !== headB)
      return false;
    headA = headA.next;
    headB = headB.next
  }
  return true;
}

//recursive
var isSameList = (headA, headB) => {
  if (headA == headB) {
    return false;
  } else if (!headA && !headB) {
    return true;
  }
  isSameList(headA.next, headB.next);
}


function maxSubarray(arr, k) {
  for (var i = 0; i <= arr.length - k; i++) {
    max = arr[i];
     for (var j = 1; j < k; j++) {
       if (arr[i + j] > max)
        max = arr[i + j];
     }
  }
  return max;
}


// // O(n^2) time
var twoSum = function(nums, target) {
    let results = [];
    for (let i=0; i< nums.length; i++) {
        for (let j=i+1; j < nums.length; j++) {
          if (nums[j] === target - nums[i]) {
            results.push([i, j])
          }
        }
    }
    return results;
};


// FACTORS OF A GIVEN NUMBER
const factorsOf = number => Array.from(Array(number), (_, i) => i).filter(i => number % i === 0);

function factors(number) {
  var arr = [];
  for (var i = 2; i < Math.sqrt(number); i++) {
    if (number % i === 0) {
      arr.push(i);
      arr.push(number/i);
    }
  }
  return arr;
}

// CHECK IF NUMBER IS PRIME
const isPrime = num => {
  for(let i = 2; i < num; i++)
    if(num % i === 0) return false;
  return num > 1;
}

// SUM OF ARRAY
var arr = [1,2,3,4];
arr.filter((a,b) => a + b);

// PRODUCT OF ARRAY
var arr = [1,2,3,4];
arr.filter((a,b) => a * b);

// HIGHEST value
Math.max(...arr);

// LOWEST value
Math.min(...arr);

// RM DUPLICATES
[...new Set(arr)]

const factorsOf = number => Array.from(Array(number), (_, i) => i).filter(i => number % i === 0);


// GREATEST COMMON FACTOR
const generalizedGCD = (arr) => {
  return arr.reduce(gcf);
}

const gcf = (a, b) => {
  if (b === 0) {
    return a;
  } else {
    return gcf(b, a % b);
  }
}

function maxSubArr(arr) {
  if (!arr.length)
    return null
  if (arr.length === 1)
    return arr[0];
  if (arr.every(i => i < 0))
    return Math.max(...arr);

  let curSum = 0;
  return arr.reduce((maxSum, number) => {
    curSum = Math.max(curSum+number, 0);
    return Math.max(curSum, maxSum);
  }, 0)
}

function bubSort(arr) {
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < arr.length; i++) {
      if (arr[i] && arr[i+1] && arr[i] > arr[i+1])
        [arr[i], arr[i+1]] = [arr[i+1], arr[i]];
        swapped = true;
    }
  } while (swapped);
  return arr;
}

const facorsOf = (num) => Array.from(Array(num), (_, i) => i).filter(i =>  num % i === 0);
const isPrime = (num) => {
  for (var i = 2; i < num; i++) {
    if (num % i === 0) {
      return false
    }
  }
  return num > 1;
}
Math.max(factorsOf(100).filter(isPrime));

function anaPalindrome(str) {
  if (str.length < 3)
    return false
  // palindrome is evens and 1 odd char count
  // count each character
  let freq = {};
  const arr = str.split('');
  arr.forEach((x) => {
      if (freq[x])
        ++freq[x]
      else
        freq[x] = 1
  });
  // count odds
  let odds = 0;
  for (var key in freq) {
    if (freq[key] % 2 === 1)
      odds += 1;
  }
  return odds < 2
}

function threeSumClosest(arr, target) {
  if (!arr || arr.length < 3)
    return false

  let arr = arr.sort();
  let diff = Number.MAX_SAFE_INTEGER;

  for (var i = 0; i < arr.length;i++) {
    let low = i+1;
    let high = arr.length;
    while (low < high) {
      const sum = arr[i] + arr[low] + arr[high];
      if (sum === target)
        return sum
      diff = Math.min(diff, Math.abs(target-sum));
      if (sum > target)
        --high
      else
        ++low
    }
  }
  return diff;
}