Patterns

Single pass; maintain running min/max and update answer greedily

When to useBest time to buy stock, jump game, gas station

iterative

Find Maximum

find_maximum

Water Plants

google_oa_water_plants

Lexicographically Smallest String

lexicographically_smallest_string

Coin Sequence

amazon_oa_coin_sequence

Minimum Number of Decreasing Subsequence Partitions

google_oa_min_decreasing_partitions

Partition Labels

partition_labels

Activate Fountain

twitter_oa_activate_fountain

Weird Faculty

twitter_oa_weird_faculty

Max Inserts to Obtain String Without 3 Consecutive 'a'

max_inserts_to_obtain_string_without_3_consecutive_a

Min Deletions To Obtain String In Right Format

min_deletions_to_obtain_string_in_right_format

Min Moves to Obtain String Without 3 Identical Consecutive Letters

min_moves_no_three_consecutive_chars

Partition String

partition_string

INITIALIZE

running tracker(s) and best result

let maxVal = nums[0];

let steps = 0; let ladle = 0;

const lastIndex = new Map();
for (let i = 0; i < s.length; i++) lastIndex.set(s[i], i);
const result = [];
let i = 0;

let longest = releaseTimes[0]; let key = keysPressed[0];

let i = 0;

let totalH = 0; let totalT = 0;
for (const c of coins) { if (c === 'H') totalH++; else totalT++; }
let best = Math.min(totalH, totalT);

let sumA = 0; let sumB = 0;
for (let i = 0; i < a.length; i++) { sumA += a[i]; sumB += b[i]; }
let count = 0;
let prefixA = a[0]; let prefixB = b[0];

const totalGas = gas.reduce((s, n) => s + n, 0);
const totalDist = dist.reduce((s, n) => s + n, 0);
if (totalGas < totalDist) return -1;
let start = 0; let tank = 0;

let partitions = 1; let prev = nums[0];

const lastIndex = new Map();
for (let i = 0; i < s.length; i++) lastIndex.set(s[i], i);
let start = 0; let end = 0; const result = [];

const n = r.length;
const reach = new Array(n).fill(0);
for (let i = 0; i < n; i++) {
  const left = Math.max(0, i - r[i]);
  const right = Math.min(n - 1, i + r[i]);
  reach[left] = Math.max(reach[left], right);
}
let count = 0; let currentEnd = 0; let nextEnd = 0; let i = 0;

const total = p.reduce((s, n) => s + (n === 1 ? 1 : -1), 0);
if (0 > total) return 0;
let alex = 0;

let countA = 0; let countOthers = 0;

let numY = 0; let minDel = 0;

let prev = null; let runLength = 0; let moves = 0;

const lastIndex = new Map();
for (let i = 0; i < s.length; i++) lastIndex.set(s[i], i);
let start = 0; let end = 0; const result = [];

TRAVERSE

for each item

for (const num of nums) {

for (let i = 0; i < bowls.length; i++) {

while (i < s.length) {
  let end = lastIndex.get(s[i]);
  let j = i;
  while (j <= end) {

for (let i = 1; i < releaseTimes.length; i++) {

for (i = 0; i < s.length - 1; i++) {

let leftH = 0; let leftT = 0;
for (let i = 0; i < coins.length - 1; i++) {

for (let i = 1; i < a.length; i++) {

for (let i = 0; i < gas.length; i++) {

for (let i = 1; i < nums.length; i++) {

for (let i = 0; i < s.length; i++) {

while (currentEnd < n - 1) {

for (let k = 1; k <= p.length; k++) {

for (let i = 0; i < s.length; i++) {

for (const c of s) {

for (const ch of s) {

for (let i = 0; i < s.length; i++) {

[UPDATE]

update running tracker; update best

  if (num > maxVal) maxVal = num;

  if (ladle < bowls[i]) { steps += 2 * i; ladle = capacity; }
  ladle -= bowls[i];
  steps += 1;

    end = Math.max(end, lastIndex.get(s[j]));
    j++;

  const duration = releaseTimes[i] - releaseTimes[i - 1];
  if (duration > longest || (duration === longest && keysPressed[i] > key)) {
    longest = duration;
    key = keysPressed[i];
  }

  if (s[i] > s[i + 1]) break;

  if (coins[i] === 'H') leftH++; else leftT++;
  best = Math.min(best, leftT + (totalH - leftH));

  if (prefixA === prefixB && 2 * prefixA === sumA && 2 * prefixB === sumB) count++;
  prefixA += a[i];
  prefixB += b[i];

  tank += gas[i] - dist[i];
  if (tank < 0) { start = i + 1; tank = 0; }

  if (nums[i] >= prev) partitions++;
  prev = nums[i];

  end = Math.max(end, lastIndex.get(s[i]));
  if (i === end) {
    result.push(end - start + 1);
    start = i + 1;
  }

  while (i <= currentEnd) {
    nextEnd = Math.max(nextEnd, reach[i]);
    i++;
  }
  count++;
  currentEnd = nextEnd;

  alex += p[k - 1] === 1 ? 1 : -1;
  const sam = total - alex;

  if (s[i] === 'a') { countA++; } else { countOthers++; countA = 0; }
  if (countA === 3) return -1;

  if (c === 'X') { minDel = Math.min(numY, minDel + 1); }
  else { numY++; }

  if (ch === prev) {
    runLength++;
  } else {
    moves += Math.floor(runLength / 3);
    runLength = 1;
    prev = ch;
  }

  end = Math.max(end, lastIndex.get(s[i]));
  if (i === end) {
    result.push(s.slice(start, end + 1));
    start = i + 1;
  }

RETURN

return best

return maxVal;

return steps;

return result;

return key;

return s.slice(0, i) + s.slice(i + 1);

return best;

return count;

return start;

return partitions;

return result;

return count;

return -1;

return 2 * (countOthers + 1) - (s.length - countOthers);

return minDel;

return moves;

return result;