[String and Math Algorithms]

Author: loiane

src/ts/algorithms/math/find-divisors.ts

@@ -0,0 +1,18 @@
+export const findDivisors = (num: number) => {
+  const divisors = [];
+
+  const sqrt = Math.floor(Math.sqrt(num));
+
+  for (let i = 1; i <= sqrt; i++) {
+    if (num % i === 0) {
+      divisors.push(i);
+      if (i !== sqrt) {
+        divisors.push(Math.floor(num / i));
+      }
+    }
+  }
+
+  divisors.sort((a, b) => a - b);
+
+  return divisors;
+};

src/ts/algorithms/math/gcd.ts

@@ -0,0 +1,22 @@
+export const gcd = (num1: number, num2: number): number => {
+  if (num1 === 0 || num2 === 0) {
+    return 0;
+  }
+  if (num1 === num2) {
+    return num1;
+  }
+  if (num1 > num2) {
+    return gcd(num1 - num2, num2);
+  }
+  return gcd(num1, num2 - num1);
+};
+
+export const gcdArray = (num: number[]) => {
+  let result = num[0];
+
+  for (let i = 1; i < num.length; i++) {
+    result = gcd(num[i], result);
+  }
+
+  return result;
+};

src/ts/algorithms/math/greatest-difference.ts

@@ -0,0 +1,20 @@
+export const greatestDifference = (numbers: number[]) => {
+  let index = 0;
+  let largest = numbers[0];
+  const length = numbers.length;
+  let number;
+  let smallest = numbers[0];
+
+  for (index; index < length; index++) {
+    number = numbers[index];
+
+    if (number > largest) {
+      largest = number;
+    }
+    if (number < smallest) {
+      smallest = number;
+    }
+  }
+
+  return largest - smallest;
+};

src/ts/algorithms/math/lcm.ts

@@ -0,0 +1,20 @@
+import { gcd } from './gcd';
+
+export const lcm = (num1: number, num2: number) => {
+  if (num1 === 0 || num2 === 0) {
+    return 0;
+  }
+  num1 = Math.abs(num1);
+  num2 = Math.abs(num2);
+  return (num1 * num2) / gcd(num1, num2);
+};
+
+export const lcmArray = (num: number[]) => {
+  let result = num[0];
+
+  for (let i = 1; i < num.length; i++) {
+    result = num[i] * result / gcd(num[i], result);
+  }
+
+  return result;
+};

src/ts/algorithms/math/primality-test.ts

@@ -0,0 +1,36 @@
+export const isPrime = (n: number) => {
+  if (n <= 1) {
+    return false;
+  }
+
+  const sqrt = Math.floor(Math.sqrt(n));
+  for (let i = 2; i < sqrt; i++) {
+    if (n % i === 0) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+export const testPrime = (n: number) => {
+  if (n <= 1) {
+    return false;
+  } else {
+    if (n === 2 || n === 3) {
+      return true;
+    } else if (n % 2 === 0) {
+      return false;
+    } else {
+      const sqrt = Math.floor(Math.sqrt(n));
+      for (let i = 3; i <= sqrt; i += 2) {
+        if (n % i === 0) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+};
+
+const isPrime2 = (n: number) => ![...Array(n).keys()].slice(2).map(i => !(n % i)).includes(true) && ![0, 1].includes(n);

src/ts/algorithms/math/sieve-eratosthenes.ts

@@ -0,0 +1,18 @@
+export const sieveOfEratosthenes = (n: number) => {
+
+  const prime: boolean[] = [];
+
+  for (let i = 0; i < n; i++) {
+    prime[i] = true;
+  }
+
+  for (let p = 2; p * p <= n; p++) {
+    if (prime[p]) {
+      for (let i = p * 2; i <= n; i += p) {
+        prime[i] = false;
+      }
+    }
+  }
+
+  return prime.filter(num => num === true);
+};

src/ts/algorithms/string/brute-force.ts

@@ -0,0 +1,22 @@
+const stringSearch = (text: string, pattern: string) => {
+  const n = text.length;
+  const m = pattern.length;
+
+  if (m > n) {
+    return -1;
+  }
+
+  for (let i = 0; i < n; i++) {
+    let j = 0;
+    for (j = 0; j < m && (i + j) < n; j++) {
+      if (text.charAt(i + j) !== pattern.charAt(j)) {
+        break;
+      }
+    }
+    if (j === m) {
+      return i;
+    }
+  }
+
+  return -1;
+};

src/ts/algorithms/string/huffman.ts

@@ -0,0 +1,46 @@
+const buildTable = (pattern: string) => {
+  const length = pattern.length;
+  const table = [];
+  let position = 2;
+  let cnd = 0;
+
+  table[0] = -1;
+  table[1] = 0;
+
+  while (position < length) {
+    if (pattern[position - 1] === pattern[cnd]) {
+      table[position++] = ++cnd;
+    } else if (cnd > 0) {
+      cnd = table[cnd];
+    } else {
+      table[position++] = 0;
+    }
+  }
+
+  return table;
+};
+
+const knuthMorrisPratt = (text: string, pattern: string) => {
+  const textLength = text.length;
+  const patternLength = pattern.length;
+  let m = 0;
+  let i = 0;
+  const table = buildTable(pattern);
+
+  while (m + i < textLength) {
+    if (pattern[i] === text[m + i]) {
+      if (i === patternLength - 1) {
+        return m;
+      }
+      i++;
+    } else if (table[i] >= 0) {
+      i = table[i];
+      m = m + i - table[i];
+    } else {
+      i = 0;
+      m++;
+    }
+  }
+
+  return textLength;
+};

src/ts/algorithms/string/knuth-morris-pratt.ts

@@ -0,0 +1,39 @@
+const base = 997;
+
+const hash = (word: string) => {
+  let h = 0;
+
+  for (let i = 0; i < word.length; i++) {
+    h += word.charCodeAt(i) * Math.pow(base, word.length - i - 1);
+  }
+
+  return h;
+};
+
+const rabinKarp = (text: string, pattern: string) => {
+  if (pattern == null || pattern.length === 0) {
+    return 0;
+  }
+
+  const hashPattern = hash(pattern);
+  let currentSubstring = text.substring(0, pattern.length);
+  let hashCurrentSubstring;
+
+  for (let i = pattern.length; i <= text.length; i++) {
+    if (hashCurrentSubstring === undefined) {
+      hashCurrentSubstring = hash(currentSubstring);
+    } else {
+      hashCurrentSubstring -= currentSubstring.charCodeAt(0) * Math.pow(base, pattern.length - 1);
+      hashCurrentSubstring *= base;
+      hashCurrentSubstring += text.charCodeAt(i);
+
+      currentSubstring = currentSubstring.substring(1) + text[i];
+    }
+
+    if (hashPattern === hashCurrentSubstring && pattern === currentSubstring) {
+      return i === pattern.length ? 0 : i - pattern.length + 1;
+    }
+  }
+
+  return -1;
+};