TypeScript Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

const message: string = "Hello, world!";
console.log(message);

Run with a TypeScript runtime or compile first:

npx tsx main.ts

This defines a typed string and logs it. It is the basic TypeScript shape for a tiny script.

Types

type User = {
  id: number;
  name: string;
  active: boolean;
};

const user: User = {
  id: 1,
  name: "Dan",
  active: true,
};

This type describes the expected object shape, then the object literal follows that contract.

Add

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Add

function add(param1: number, param2: number): number {
  return param1 + param2;
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Add Border

function addBorder(picture: string[]): string[] {
  const width = picture[0].length;
  const bordered = picture.map((row) => `*${row}*`);
  const border = "*".repeat(width + 2);
  return [border, ...bordered, border];
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Adjacent Elements Product

function adjacentElementsProduct(inputArray: number[]): number {
  let max = -Infinity;

  for (let i = 0; i < inputArray.length - 1; i++) {
    max = Math.max(max, inputArray[i] * inputArray[i + 1]);
  }

  return max;
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Almost Magic Square

function almostMagicSquare(a: number[]): number[] {
  const rowSum = [0, 0, 0];
  const colSum = [0, 0, 0];
  let maxSum = 0;

  const grid: number[][] = [a.slice(0, 3), a.slice(3, 6), a.slice(6, 9)];

  for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
      rowSum[i] += grid[i][j];
      colSum[i] += grid[j][i];
    }
  }

  for (let k = 0; k < 3; k++) {
    maxSum = Math.max(maxSum, rowSum[k]);
    maxSum = Math.max(maxSum, colSum[k]);
  }

  for (let i = 0, j = 0; i < 3 && j < 3; ) {
    const diff = Math.min(maxSum - rowSum[i], maxSum - colSum[j]);
    grid[i][j] += diff;
    rowSum[i] += diff;
    colSum[j] += diff;

    if (rowSum[i] === maxSum) {
      i++;
    }
    if (colSum[j] === maxSum) {
      j++;
    }
  }

  return grid.flat();
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Are Equally Strong

function areEquallyStrong(
  yourLeft: number,
  yourRight: number,
  friendsLeft: number,
  friendsRight: number
): boolean {
  return (
    Math.max(yourRight, yourLeft) === Math.max(friendsLeft, friendsRight) &&
    Math.min(yourLeft, yourRight) === Math.min(friendsRight, friendsLeft)
  );
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Array Change

function arrayChange(a: number[]): number {
  let min = 0;
  for (let k = 0; k < a.length - 1; k++) {
    if (a[k] >= a[k + 1]) {
      const dif = a[k] - a[k + 1] + 1;
      a[k + 1] += dif;
      min += dif;
    }
  }

  return min;
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Array Maximal Adjacement Difference

function arrayMaximalAdjacentDifference(a: number[]): number {
  let dif = 0;
  for (let i = 1; i < a.length - 1; i++) {
    dif = Math.max(dif, Math.abs(a[i] - a[i - 1]), Math.abs(a[i] - a[i + 1]));
  }

  return dif;
}

This checks the gap between each pair of neighbors and returns the largest difference.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Binary Gap

function binaryGap(n: number): number {
  const trimmed = n.toString(2).replace(/^0+|0+$/g, "");
  const zeroes = trimmed.split("1");

  let gap = 0;
  for (const zero of zeroes) {
    gap = Math.max(gap, zero.length);
  }

  return gap;
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Bracket

function bracket(s: string): number {
  const stack: string[] = [];

  for (const v of s) {
    switch (v) {
      case ")":
        if (stack.length === 0 || stack.pop() !== "(") {
          return 0;
        }
        break;
      case "]":
        if (stack.length === 0 || stack.pop() !== "[") {
          return 0;
        }
        break;
      case "}":
        if (stack.length === 0 || stack.pop() !== "{") {
          return 0;
        }
        break;
      default:
        if (v) {
          stack.push(v);
        }
        break;
    }
  }

  return stack.length === 0 ? 1 : 0;
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

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.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

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.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

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.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

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.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

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.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

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.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

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.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

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.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

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.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Distinct

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

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

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Dominator

function dominator(a: number[]): number {
  let size = 0;
  let value = 0;
  let index = 0;

  a.forEach((v, k) => {
    if (size === 0) {
      size++;
      value = v;
      index = k;
    } else if (value !== v) {
      size--;
    } else {
      size++;
    }
  });

  const candidate = size > 0 ? value : -1;

  let count = 0;
  for (const v of a) {
    if (v === candidate) {
      count++;
    }
  }

  if (count <= a.length / 2) {
    index = -1;
  }

  return index;
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Equi Leader

function equiLeader(a: number[]): number {
  let leaderSize = 0;
  let value = 0;

  for (const v of a) {
    if (leaderSize === 0) {
      leaderSize++;
      value = v;
    } else if (value !== v) {
      leaderSize--;
    } else {
      leaderSize++;
    }
  }

  const candidate = leaderSize > 0 ? value : -1;

  let leaderCount = 0;
  for (const v of a) {
    if (v === candidate) {
      leaderCount++;
    }
  }

  let leader = -1;
  if (leaderCount > a.length / 2) {
    leader = candidate;
  }

  const count = a.length;
  let lLeaderCount = 0;
  let equiLeaders = 0;

  for (let k = 0; k < count; k++) {
    const v = a[k];
    const leftHalf = Math.trunc((k + 1) / 2);
    const rightHalf = Math.trunc((count - k - 1) / 2);
    if (v === leader) {
      lLeaderCount++;
    }

    const rLeaderCount = leaderCount - lLeaderCount;
    if (lLeaderCount > leftHalf && rLeaderCount > rightHalf) {
      equiLeaders++;
    }
  }

  return equiLeaders;
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Fib Frog

function fibFrog(a: number[]): number {
  const size = a.length;

  const fib: number[] = [0, 1];
  for (let i = 1; fib[i] <= size; ) {
    i++;
    fib[i] = fib[i - 1] + fib[i - 2];
  }

  type Path = { idx: number; jmp: number };
  const paths: Path[] = [{ idx: -1, jmp: 0 }];
  const steps: boolean[] = new Array(size).fill(false);

  while (paths.length > 0) {
    const path = paths.shift() as Path;
    for (let i = fib.length - 1; i >= 2; i--) {
      const idx = path.idx + fib[i];
      if (idx === size) {
        return path.jmp + 1;
      }
      if (idx > size || steps[idx] || a[idx] === 0) {
        continue;
      }
      if (a[idx] === 1) {
        steps[idx] = true;
        paths.push({ idx, jmp: path.jmp + 1 });
      }
    }
  }

  return -1;
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Fish

function fish(a: number[], b: number[]): number {
  const size = a.length;
  let dead = 0;
  const downstream: number[] = [];

  for (let i = 0; i < size; i++) {
    if (b[i] === 1) {
      downstream.push(a[i]);
    } else if (downstream.length > 0) {
      while (downstream.length > 0) {
        dead++;
        if (a[i] > downstream[downstream.length - 1]) {
          downstream.pop();
        } else {
          break;
        }
      }
    }
  }

  return size - dead;
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Flags

function flags(a: number[]): number {
  const size = a.length;
  const peaks: boolean[] = [false];
  const next: number[] = [];

  for (let i = 1; i < size; i++) {
    peaks[i] = a[i - 1] < a[i] && a[i] > (a[i + 1] ?? 0);
  }

  next[size - 1] = -1;
  for (let i = size - 2; i >= 0; i--) {
    next[i] = peaks[i] ? i : next[i + 1];
  }

  let i = 1;
  let result = 0;
  while (i * (i - 1) <= size) {
    let pos = 0;
    let num = 0;
    while (pos < size && num < i) {
      pos = next[pos];
      if (pos === -1) {
        break;
      }
      ++num;
      pos += i;
    }
    i++;
    result = Math.max(result, num);
  }

  return result;
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Frog Jmp

function frogJmp(x: number, y: number, d: number): number {
  return Math.ceil((y - x) / d);
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Frog River One

function frogRiverOne(x: number, a: number[]): number {
  const existing = new Set<number>();

  for (let k = 0; k < a.length; k++) {
    const i = a[k];
    if (!existing.has(i) && i <= x) {
      existing.add(i);
      if (existing.size === x) {
        return k;
      }
    }
  }

  return -1;
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Genomic Range Query

function genomicRangeQuery(s: string, p: number[], q: number[]): number[] {
  const r: number[] = [];

  for (let k = 0; k < p.length; k++) {
    const subStr = s.slice(p[k], q[k] + 1);
    if (subStr.includes("A")) {
      r.push(1);
    } else if (subStr.includes("C")) {
      r.push(2);
    } else if (subStr.includes("G")) {
      r.push(3);
    } else {
      r.push(4);
    }
  }

  return r;
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Is Ipv 4 Adress

function isIPv4Address(inputString: string): boolean {
  const parts = inputString.split(".");

  for (const v of parts) {
    const n = Number(v);
    if (v === "" || Number.isNaN(n) || n > 255 || v !== String(Math.trunc(n))) {
      return false;
    }
  }

  return parts.length === 4;
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Ladder

function ladder(a: number[], b: number[]): number[] {
  const size = a.length;
  const r: number[] = new Array(size).fill(0);
  const mod = (1 << Math.max(...b)) - 1;

  const fib: number[] = [0, 1];
  const limit = Math.max(...a);
  for (let i = 2; i < limit + 2; i++) {
    fib[i] = (fib[i - 1] + fib[i - 2]) & mod;
  }

  for (let i = 0; i < size; i++) {
    r[i] = fib[a[i] + 1] & ((1 << b[i]) - 1);
  }

  return r;
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Largest String

function largestString(s: string): string {
  const chars = s.split("");
  let cur = "";
  let i = chars.length - 1;

  while (i >= 0) {
    cur = chars[i] + cur;

    if (cur.length === 3) {
      if (cur === "abb") {
        chars[i] = "b";
        chars[i + 1] = "a";
        chars[i + 2] = "a";

        if (chars[i + 4] !== undefined && chars[i + 4] === "b") {
          i += 4 + 1;
        } else if (chars[i + 3] !== undefined && chars[i + 3] === "b") {
          i += 3 + 1;
        } else if (chars[i + 2] === "b") {
          i += 2 + 1;
        }
      }
      if (chars[i + 1] === "b") {
        i += 1 + 1;
      } else {
        i += 1;
      }
      cur = "";
    }

    i--;
  }

  return chars.join("");
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Counters

function maxCounters(n: number, a: number[]): number[] {
  const counters: number[] = new Array(n).fill(0);
  let maxCounter = 0;
  let lastUpdate = 0;
  const condition = n + 1;

  for (const v of a) {
    if (v <= n) {
      const index = v - 1;
      if (counters[index] < lastUpdate) {
        counters[index] = lastUpdate;
      }
      counters[index]++;
      maxCounter = counters[index] > maxCounter ? counters[index] : maxCounter;
    }
    if (v === condition) {
      lastUpdate = maxCounter;
    }
  }

  return counters.map((v) => (v < lastUpdate ? lastUpdate : v));
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Double Slice Sum

function maxDoubleSliceSum(a: number[]): number {
  const size = a.length;
  if (size < 3) {
    return 0;
  }

  const p1: number[] = new Array(size).fill(0);
  const p2: number[] = new Array(size).fill(0);
  p1[1] = 0;
  p2[size - 2] = 0;

  for (let i = 2; i < size - 1; i++) {
    p1[i] = Math.max(0, p1[i - 1] + a[i - 1]);
    p2[size - i - 1] = Math.max(0, p2[size - i] + a[size - i]);
  }

  let sum = p1[1] + p2[1];
  for (let i = 1; i < size - 1; i++) {
    sum = Math.max(sum, p1[i] + p2[i]);
  }

  return sum;
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Product Of Three

function maxProductOfThree(a: number[]): number {
  const sorted = [...a].sort((x, y) => x - y);
  const c = sorted.length;

  return Math.max(
    sorted[c - 1] * sorted[c - 2] * sorted[c - 3],
    sorted[0] * sorted[1] * sorted[c - 1]
  );
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Profit

function maxProfit(a: number[]): number {
  let price = a[0];
  let profit = 0;

  for (const v of a) {
    price = Math.min(price, v);
    profit = Math.max(profit, v - price);
  }

  return profit;
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Max Slice Sum

function maxSliceSum(a: number[]): number {
  let tmp = -Infinity;
  let max = -Infinity;

  for (const v of a) {
    tmp = Math.max(tmp + v, v);
    max = Math.max(max, tmp);
  }

  return max;
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Min Avg Two Slice

function minAvgTwoSlice(a: number[]): number {
  let idx = 0;
  let min = (a[0] + a[1]) / 2;

  for (let i = 0; i < a.length - 1; i++) {
    let cur = (a[i] + a[i + 1]) / 2;
    if (a[i + 2] !== undefined) {
      const three = (a[i] + a[i + 1] + a[i + 2]) / 3;
      cur = cur < three ? cur : three;
    }
    if (cur < min) {
      min = cur;
      idx = i;
    }
  }

  return idx;
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Min Perimeter Rectangle

function minPerimeterRectangle(n: number): number {
  let i = 1;
  let min = Infinity;

  while (i * i < n) {
    if (n % i === 0) {
      min = Math.min(min, 2 * (i + n / i));
    }
    i++;
  }

  return min;
}

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Missing Integer

function missingInteger(a: number[]): number {
  let min = 1;
  const unique = [...new Set(a)].sort((x, y) => x - y);

  for (const v of unique) {
    if (v > 0) {
      if (min !== v) {
        break;
      }
      min++;
    }
  }

  return min;
}

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Nesting

function nesting(s: string): number {
  if (s === "") {
    return 1;
  }

  const stack: string[] = [];
  for (const v of s) {
    if (v === ")") {
      if (stack.length === 0 || stack.pop() !== "(") {
        return 0;
      }
    } else if (v) {
      stack.push(v);
    }
  }

  return stack.length === 0 ? 1 : 0;
}

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Number Of Disc Intersections

function numberOfDiscIntersections(a: number[]): number {
  let sum = 0;
  let active = 0;
  const c = a.length;
  const start: number[] = new Array(c).fill(0);
  const end: number[] = new Array(c).fill(0);

  for (let k = 0; k < c; k++) {
    const v = a[k];
    const startKey = k < v ? 0 : k - v;
    start[startKey]++;

    const endKey = k + v >= c ? c - 1 : k + v;
    end[endKey]++;
  }

  for (let k = 0; k < c; k++) {
    sum += active * start[k] + (start[k] * (start[k] - 1)) / 2;
    active += start[k] - end[k];
    if (sum > 10000000) {
      return -1;
    }
  }

  return sum;
}

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Odd Occurrences In Array

function oddOccurrencesInArray(a: number[]): number | null {
  const count = new Map<number, number>();

  for (const value of a) {
    if (!count.has(value)) {
      count.set(value, 1);
    } else {
      count.delete(value);
    }
  }

  const first = count.keys().next();
  return first.done ? null : first.value;
}

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Palindrome Rearranging

function palindromeRearranging(inputString: string): boolean {
  const counts = new Map<string, number>();

  for (const ch of inputString) {
    counts.set(ch, (counts.get(ch) ?? 0) + 1);
  }

  let c = 0;
  for (const v of counts.values()) {
    if (v % 2 !== 0) {
      c++;
    }
  }

  return c <= 1;
}

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Passing Cars

function passingCars(a: number[]): number {
  let passingCars = 0;
  let multiply = 0;

  for (const i of a) {
    if (i === 0) {
      multiply++;
    } else if (multiply > 0) {
      passingCars += multiply;
      if (passingCars > 1000000000) {
        return -1;
      }
    }
  }

  return passingCars;
}

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Peaks

function peaks(a: number[]): number {
  const n = a.length;
  if (n <= 2) {
    return 0;
  }

  const sum: number[] = new Array(n).fill(0);
  let last = -1;
  let dist = 0;

  for (let i = 1; i + 1 < n; ++i) {
    sum[i] = sum[i - 1];
    if (a[i] > a[i - 1] && a[i] > a[i + 1]) {
      dist = Math.max(dist, i - last);
      last = i;
      ++sum[i];
    }
  }

  sum[n - 1] = sum[n - 2];
  if (sum[n - 1] === 0) {
    return 0;
  }

  dist = Math.max(dist, n - last);

  for (let i = (dist >> 1) + 1; i < dist; ++i) {
    if (n % i === 0) {
      last = 0;
      let j = i;
      for (; j <= n; j += i) {
        if (sum[j - 1] <= last) {
          break;
        }
        last = sum[j - 1];
      }
      if (j > n) {
        return n / i;
      }
    }
  }

  for (last = dist; n % last; ) {
    ++last;
  }

  return Math.trunc(n / last);
}

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Perm Check

function permCheck(a: number[]): number {
  const sorted = [...a].sort((x, y) => x - y);

  for (let k = 0; k < sorted.length; k++) {
    if (sorted[k + 1] !== undefined && sorted[k] !== k + 1) {
      return 0;
    }
  }

  return 1;
}

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Perm Missing Element

function permMissingElement(a: number[]): number {
  const sorted = [...a].sort((x, y) => x - y);

  for (let k = 0; k < sorted.length; k++) {
    if (sorted[k] !== k + 1) {
      return k + 1;
    }
  }

  return sorted.length + 1;
}

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Plagiarism Check

function isNumeric(value: string): boolean {
  return value !== "" && !Number.isNaN(Number(value));
}

function plagiarismCheck(code1: string[], code2: string[]): boolean {
  let c1 = code1.join(" ");
  let c2 = code2.join(" ");

  if (c1 === c2) {
    return false;
  }

  const d1 = c1.match(/[\w]+/g) ?? [];
  const d2 = c2.match(/[\w]+/g) ?? [];

  const rCand = new Map<string, string>();
  for (let k = 0; k < d1.length; k++) {
    const v = d1[k];
    if (v !== d2[k] && !isNumeric(v)) {
      rCand.set(v, d2[k]);
    }
  }

  for (const [orig] of rCand) {
    c1 = c1.replace(new RegExp(`(\\W)${orig}(\\W*)`, "g"), `$1PLACEHOLDER${orig}$2`);
    c1 = c1.replace(new RegExp(`(\\W)${orig}`, "g"), `$1PLACEHOLDER${orig}`);
  }

  for (const [orig, repl] of rCand) {
    c1 = c1.replace(new RegExp(`(\\W)PLACEHOLDER${orig}(\\W)`, "g"), `$1${repl}$2`);
    c1 = c1.replace(new RegExp(`(\\W)PLACEHOLDER${orig}`, "g"), `$1${repl}`);
  }

  return c1 === c2;
}

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Shape Area

function shapeArea(n: number): number {
  return n > 1 ? shapeArea(n - 1) + 4 * (n - 1) : 1;
}

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Stone Blocks

function stoneBlocks(h: number[]): number {
  const height: number[] = [];
  let index = 0;
  let blocks = 0;

  for (const i of h) {
    while (index > 0 && height[index - 1] > i) {
      index--;
    }
    if (index > 0 && height[index - 1] === i) {
      continue;
    }

    height[index] = i;
    blocks++;
    index++;
  }

  return blocks;
}

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Tape Equilibrium

function tapeEquilibrium(a: number[]): number {
  let firstPart = 0;
  let secondPart = a.reduce((sum, v) => sum + v, 0);
  let min = Infinity;

  for (let i = 0; i < a.length - 1; i++) {
    firstPart += i;
    secondPart -= i;
    const difference = Math.abs(firstPart - secondPart);
    min = difference < min ? difference : min;
  }

  return min;
}

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

TypeScript Triangle

function triangle(a: number[]): number {
  const sorted = [...a].sort((x, y) => x - y);
  const c = sorted.length;
  if (c < 3) {
    return 0;
  }

  for (let i = 0; i < c - 2; i++) {
    if (sorted[i] > 0 && sorted[i] > sorted[i + 2] - sorted[i + 1]) {
      return 1;
    }
  }

  return 0;
}

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.