Pattern count

k-merFrequency.js

/**
ALGORITHM:
PatternCount(Text, Pattern)
  count ← 0
  for i ← 0 to |Text| − |Pattern|
    if Text(i, |Pattern|) = Pattern
      count ← count + 1
  return count
**/

const patternCount = (text, pattern) => {
  let count = 0
  for(let i = 0; i < text.length; i++){
    if(text.substring(i, i + pattern.length) === pattern){
      count += 1
    }
  }
  return count;
}

/** 
ALGORITHM
FrequentWords(Text, k)
    FrequentPatterns ← an empty set
    for i ← 0 to |Text| − k
        Pattern ← the k-mer Text(i, k)
        Count(i) ← PatternCount(Text, Pattern)
    maxCount ← maximum value in array Count
    for i ← 0 to |Text| − k
        if Count(i) = maxCount
            add Text(i, k) to FrequentPatterns
    remove duplicates from FrequentPatterns
    return FrequentPatterns
*/

const frequentWords= (text, k) => {
  const frequentPatterns = [];
  let count = []
  for(i=0; i < ((text.length + 1) - k) ; i++){
    let pattern = text.substring(i, i+k)
    count[i] = patternCount(text, pattern)
  }
  const maxCount = Math.max(...count);
  for(i=0; i < ((text.length + 1) - k); i++){
    if(count[i] == maxCount){
      frequentPatterns.push(text.substring(i, i+k))
    }
  }
  return Array.from(new Set(frequentPatterns))
}

/** FrequencyTable(Text, k)
    freqMap ← empty map
    n ← |Text|
    for i ← 0 to n − k
        Pattern ← Text(i, k)
        if freqMap[Pattern] doesn't exist
            freqMap[Pattern]← 1
        else
           freqMap[pattern] ←freqMap[pattern]+1 
    return freqMap
  **/

const maxOfFreqMap = (freqMap) => {
  let result;
  Object.entries(frequencyMap).reduce((ini, curr) => {
    if(ini[1] > curr[1]){
      result = ini
      return ini
    } else {
      result = curr
      return curr
    }
  })
  return result
}

const optimisedFrequentWords = (text, k) => {
  const frequencyMap = {};
  const textLength = text.length;
  for (let index = 0; index <= textLength - 3; index++) {
    let pattern = text.substring(index, index+k)
    if(!frequencyMap[pattern]){
      frequencyMap[pattern] = 1
    }else {
      frequencyMap[pattern] = frequencyMap[pattern] + 1
    }
  }
  return maxOfFreqMap(frequencyMap)
}