TypeScript Notes

TypeScript Century From Year

function centuryFromYear(year: number): number {
  return Math.ceil(year / 100);
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

TypeScript Check Palindrome

function checkPalindrome(inputString: string): boolean {
  return inputString.split("").reverse().join("") === inputString;
}

This compares the string with its reverse. If they match, it is a palindrome.

TypeScript Chocolates By Numbers

function chocolatesByNumbers(n: number, m: number): number {
  const gcd = (x: number, y: number): number => (x % y === 0 ? y : gcd(y, x % y));

  return (n * m) / gcd(n, m) / m;
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

TypeScript Common Prime Divisors

function commonPrimeDivisors(a: number[], b: number[]): number {
  const gcd = (n: number, m: number): number => (n % m === 0 ? m : gcd(m, n % m));

  const removeCommonPrimeDivisors = (n: number, m: number): number => {
    while (n !== 1) {
      const d = gcd(n, m);
      if (d === 1) {
        break;
      }
      n /= d;
    }

    return n;
  };

  let counter = 0;
  for (let i = 0; i < a.length; i++) {
    let x = a[i];
    let y = b[i];
    const d = gcd(x, y);

    x = removeCommonPrimeDivisors(x, d);
    if (x !== 1) {
      continue;
    }

    y = removeCommonPrimeDivisors(y, d);
    if (y === 1) {
      counter++;
    }
  }

  return counter;
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

TypeScript Count Div

function countDiv(a: number, b: number, k: number): number {
  const firstDiv = a % k === 0 ? a : a + (k - (a % k));
  const lastDiv = b - (b % k);

  return (lastDiv - firstDiv) / k + 1;
}

This counts how many numbers in a range are divisible by K without looping through every value.

TypeScript Count Factors

function countFactors(n: number): number {
  let count = 0;
  let i = 1;
  while (i * i < n) {
    if (n % i === 0) {
      count += 2;
    }
    i++;
  }
  if (i * i === n) {
    ++count;
  }

  return count;
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

TypeScript Count Non Divisible

function countNonDivisible(a: number[]): number[] {
  const size = a.length;
  const nondivisor: number[] = new Array(size).fill(0);
  const occurences: number[] = new Array(Math.max(...a) + 1).fill(0);

  for (const v of a) {
    occurences[v]++;
  }

  for (let k = 0; k < size; k++) {
    const v = a[k];
    let count = 0;
    let i = 1;
    while (i * i <= v) {
      if (v % i === 0) {
        count += occurences[i];
        if (v / i !== i) {
          count += occurences[v / i];
        }
      }
      i++;
    }
    nondivisor[k] = size - count;
  }

  return nondivisor;
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

TypeScript Count Semi Primes

function countSemiPrimes(n: number, p: number[], q: number[]): number[] {
  const primes: boolean[] = new Array(n + 1).fill(true);
  const semiPrimes: number[] = new Array(n + 1).fill(0);
  const semiPrimeCounts: number[] = new Array(p.length).fill(0);

  for (let i = 2; i * i <= n; i++) {
    if (primes[i]) {
      for (let k = i * i; k <= n; k += i) {
        primes[k] = false;
      }
    }
  }

  for (let k = 2; k * k <= n; k++) {
    if (primes[k]) {
      for (let i = 2; i * k <= n; i++) {
        if (primes[i]) {
          semiPrimes[k * i] = 1;
        }
      }
    }
  }

  for (let i = 1; i <= n; i++) {
    semiPrimes[i] += semiPrimes[i - 1];
  }

  for (let k = 0; k < p.length; k++) {
    semiPrimeCounts[k] = semiPrimes[q[k]] - semiPrimes[p[k] - 1];
  }

  return semiPrimeCounts;
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

TypeScript Cyclic Rotation

function cyclicRotation(a: number[], k: number): number[] {
  const result = [...a];

  if (result.length > 0) {
    for (let i = 0; i < k; i++) {
      const popped = result.pop() as number;
      result.unshift(popped);
    }
  }

  return result;
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

TypeScript Distinct

function distinct(a: number[]): number {
  return new Set(a).size;
}

This counts unique values by tracking what has already been seen.