Some common functions I used for white board coding as a comp sci graduate.

common_functions.js

let isFactor = (num) => {
    for(i=0; i <= num; i++){
        if(num % i === 0) {
            return true
        } else {
            return false
            
        }
    }
}

let isVowel = (str) => {
    let found = false;
    for(i=0; i < str.length; i++){
        let vowels = 'aeiouAEIOU'
        if(vowels.indexOf(str[i]) !== -1){
           found = true
        }
    }
    return found;
}

let uncompress = (string) => {
    let uncompressedPhrase = '';
    for(let i = 0; i < string.length; i++){
        if(!isNaN(string[i])){
            uncompressedPhrase = uncompressedPhrase + string[i-1].repeat(Number(string[i]));
        }
    }
    return uncompressedPhrase
    
}


// your code here

let isPrime = (num) => {
    let isPrime = true;
    
    // check if number is equal to 1
    if (num === 1) {
        isPrime = false
    }
    else if (num > 1) {
    // looping through 2 to number-1
    for (let i = 2; i < num; i++) {
        if (num % i == 0) {
            isPrime = false;
            break;
            }
        }
    }
    return isPrime;
    
} 

let choosePrimes = (nums) => {
    primeArray = []
    for(let i = 0; i < nums.length; i++){
        if(isPrime(nums[i])){
            primeArray.push(nums[i])
        }
    }
    return primeArray
}



let fizzBuzz = (max) => {
    let fizBuzzedArray = []
    for(let i = 0; i < max; i++){
        if(!(i % 3 === 0 && i % 5 === 0) && (i % 3 === 0 || i % 5 === 0)){
            fizBuzzedArray.push(i)
        } 
    }    return fizBuzzedArray

}


let hasVowel = (letter) => {
    let vowels = 'aeiouAEIOU'
    let found = false;
        if(vowels.includes(letter)){
           found = true
        }
    return found;
}

let sliceWordByVowel = (word) => {
    let slicedWord = word
    for(i=word.length-1; i >= 0; i--){
        if(hasVowel(word[i])){
           return slicedWord = slicedWord + slicedWord.slice(i)
        }
    }
    return slicedWord
}


let repeatingTranslate = (sentence) => {
    sentenceArray = sentence.split(' ')
    for(let i = 0; i < sentenceArray.length; i++){
        if(sentenceArray[i].length > 2) {
            if(hasVowel(sentenceArray[i].charAt(sentenceArray[i].length-1))){
                sentenceArray[i] = sentenceArray[i] + sentenceArray[i]
            }
            
            else {
                sentenceArray[i] = sliceWordByVowel(sentenceArray[i])
            }
            
        }
    }
    return sentenceArray.join(' ')
} 

let doubleSequence = (base, length) => {
    if (length <= 0){ 
        return [];
    }
    let lengthSequence = [base]
    for(let i = 1; i < length; i++){
        let nextSeq = lengthSequence[i-1]*2
        lengthSequence.push(nextSeq)
    }
    return lengthSequence
};

let unique = (array) => {
    uniqueArray = [array[0]]
    for (let i = 1; i < array.length; i++){
        if(uniqueArray.indexOf(array[i]) === -1){
            uniqueArray.push(array[i])
        }
    }
    return uniqueArray
};

let fibonacciSequence = (num) => {
    fibonacciSeq = []
    if(num > 0) {fibonacciSeq.push(1)}
    for(let i = 1; i < num; i++){
        if(fibonacciSeq[0] === 1 && i === 1){
        fibonacciSeq.push(1)
        } else {
            fibonacciSeq.push(fibonacciSeq[i-1] + fibonacciSeq[i-2])
        }
    }
    return fibonacciSeq
}

let sequenceGenerator = (num) => {
    let sequenceTotal = 0;
    for(let i = 1; i <= num; i++){
        sequenceTotal += i;
    }
    return sequenceTotal
}

let rotateRight = function(array, num) {
    let copy = array.slice();
    // console.log(copy, 'copy of array')
    for (let i = 0; i < num; i++) {
        let el = copy.pop();
        // console.log(el, 'current el')
        copy.unshift(el);
        // console.log(copy, 'current copy')
        // console.log('cycle', i)

    }

    return copy;
};

let rotate = function(array, num) {
    if (isPostive(num)){
        for (let i = 0; i < num; i++) {
            array.unshift(array.pop());
        }
        
    } else {
       let leftShift = num * -1;
        for (let i = 0; i < leftShift; i++) {
            array.push(array.shift());
        }
    }

};


let reverseSentence = (sentence) => {
    let sentenceArray = sentence.split(' ');
    let reversedArray = []
    let originalLength = sentenceArray.length;
    for(let i = 0; i < originalLength; i++){
        reversedArray.unshift(sentenceArray.shift())
    }
    return reversedArray.join(' ')
};


let hasVowel = (str) => {
    let found = false;
    for(i=0; i < str.length; i++){
        let vowels = 'aeiou'
        if(vowels.indexOf(str[i]) !== -1){
           found = true
        }
    }
    return found;
}

let removeVowels = (str) => {
    let newArray = []
    let stringArray = str.split();
    for(i=0; i < str.length; i++){
        let vowels = 'aeiou'
        if(vowels.indexOf(str[i]) === -1){
           newArray.push(str[i])
        }
    }
    return newArray.join('');
}

let removeFirstConsonant = (str) => {
    let vowels = 'aeiouAEIOU'
    for(let i = 0; i < str.length; i++){
        if(vowels.includes(str[i])){
          return str.slice(i)
        }
    }
    return str
}

let pairsMaker = (arr) => {
    let pairsArray = []
    for(let i = 0; i < arr.length; i++){
        let currentPairArray = []
        for(let k = i+ 1; k < arr.length; k++){
            pairsArray.push([arr[i],arr[k]])
        }
    }
    return pairsArray 
}

let twoDimensionalSum = (arr) => {
    let sumOfNumbers = 0;
    for(let i = 0; i < arr.length; i++){
        for(let k = 0; k < arr[i].length; k++){
            sumOfNumbers += arr[i][k]
        }
    }
    return sumOfNumbers 
}



function matrixByColumn(matrix) {
  const height = matrix.length;
  const width = matrix[0].length;

  const maxColumns = [];
  for (let col = 0 ; col < width ; col++) {

    for (let row = 0 ; row < height ; row++) {

        console.log(col, matrix[row][col])
    }
      
  }
    
}



let matrixAddition = (arr1, arr2) => {
 const height = arr1.length;
 const width = arr1[0].length;
 
 let matrixAdditionArray = [];
  for (let row = 0 ; row < height ; row++) {
      let arrayToAdd = []
      for(let col = 0; col < width; col++){
         arrayToAdd.push(arr1[row][col] + arr2[row][col])
    }
      matrixAdditionArray.push(arrayToAdd)
  }
  return matrixAdditionArray
}


let findDuplicates = (array) => {
    const set = new Set(array);
    
    const duplicates = array.filter(item => {
        if (set.has(item)) {
            set.delete(item);
        } else {
            return item;
        }
})
    return duplicates
}


let findHighestInMatrixColumns = (matrix) => {
    let biggestInColumns = []
    const height = matrix.length;
    const width = matrix[0].length;
    for (let row = 0 ; row < height ; row++) {
      let currentMax = matrix[row][0]
        for (let col = 1 ; col < width ; col++) {
         if(currentMax > matrix[row][col]){
             currentMax = matrix[row][col]
         }
        }     
    biggestInColumns.push(currentMax)
  }
  return biggestInColumns
}


let findMinInMatrixRow = (matrix) => {
    let minInRow = []
    const height = matrix.length;
    const width = matrix[0].length;
    for (let col = 0 ; col < width ; col++) {
      let currentMax = matrix[0][col]
        for (let row = 1 ; row < height ; row++) {
            if(currentMax < matrix[row][col]){
                currentMax = matrix[row][col]
            }
        }
    minInRow.push(currentMax)
  }
    return minInRow
}

let findDuplicates = (array) => {
    
    let duplicates = []
    for(let i = 0; i < array[0].length; i++){
        for(let k = 0; k < array[1].length; k++){
            // console.log(array[0][i], array[1][k])
            if(array[0][i]=== array[1][k]){
                // console.log('found!', array[0][i], array[1][k])
                duplicates.push(array[0][i])
                break;
            }
        }
    }
    
    return duplicates
}

let generateEmpty3dArray = (array) => {
    let generatedArray = []
    for(let i = 0; i < array.length; i++){
        generatedArray.unshift([])
    }
    
    return generatedArray
}

let pyramidArray = (arr1) => {
    let pyramidArrayArray = generateEmpty3dArray(arr1);
    pyramidArrayArray[pyramidArrayArray.length-1] = arr1
  for (let i =  pyramidArrayArray.length-1 ; i >=0 ; i--) {
      let newPyramidLevel = []
      for(let k = 0 ; k < pyramidArrayArray[i].length-1 ; k++){
        pyramidArrayArray[i-1].push(pyramidArrayArray[i][k]+pyramidArrayArray[i][k+1])
        }
  }
  return pyramidArrayArray
}