TypeScript Notes

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.