Patterns

Sort first, then iterate to find pairs/sequences/answer

When to useProblems easier after sorting: arithmetic progression, min difference pairs, max product of K

iterative

When to Sort First

when_to_sort_first

Arithmetic Progression

can_make_arithmetic_progression

Minimum Absolute Difference Pairs

minimum_difference_pairs

Maximum Product of Three

max_product_of_three

Cut off Rank

amazon_oa_cut_off_rank

Min Steps to Make Piles Equal Height

min_steps_to_make_piles_equal_height

Parking Dilemma

twitter_oa_parking_dilemma

Number of Swaps to Sort

amazon_oa_number_of_swaps_to_sort

Storage Optimization

amazon_oa_storage_optimization

Optimizing Box Weights

optimizing_box_weights

Minimum Amplitude

google_oa_min_amplitude

Sequence Check

sequence_check

Amazon OA — Maximum Quality

amazon_oa_maximum_quality

INITIALIZE

sort the input; init accumulator/best result

const sorted = [...arr].sort((a, b) => a - b);

arr.sort((a, b) => a - b);
const diff = arr[1] - arr[0];

arr.sort((a, b) => a - b);
let minDiff = Infinity;
const result = [];

nums.sort((a, b) => a - b);
const n = nums.length;

const sorted = [...scores].sort((a, b) => b - a);
let count = 0; let rank = 1;

if (nums.length < 2) return 0;
nums.sort((a, b) => a - b);
let steps = 0;

pos.sort((a, b) => a - b);
let best = Infinity;

const sorted = [...arr].sort((a, b) => a - b);
const indexOf = new Map();
for (let i = 0; i < arr.length; i++) indexOf.set(arr[i], i);
let swaps = 0;
const current = [...arr];

const horizontal = [...hCuts].sort((a, b) => a - b);
const vertical = [...vCuts].sort((a, b) => a - b);
let maxRowGap = 0; let prev = 0;

const sorted = [...weights].sort((a, b) => b - a);
const total = sorted.reduce((acc, v) => acc + v, 0);
const subset = [];
let subsetSum = 0;

if (entries.length <= maxReplacement + 1) return 0;
entries.sort((a, b) => a - b);
const n = entries.length;
let best = Infinity;

const sorted = [...arr].sort((a, b) => a - b);
const diff = sorted[1] - sorted[0];

const sorted = [...packages].sort((a, b) => b - a);
let sum = 0;

TRAVERSE

for i in 0..n

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

for (let i = 2; i < arr.length; i++) {

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

—

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

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

for (let i = 0; i + k - 1 < pos.length; i++) {

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

for (const cut of horizontal) {

for (const weight of sorted) {

for (let i = 0; i <= maxReplacement; i++) {

for (let i = 2; i < sorted.length; i++) {

for (let i = 0; i < m; i++) {

[DERIVE]

use arr[i] and neighbors (sorted property)

  if (sorted[i] === sorted[i - 1]) return true;

  if (arr[i] - arr[i - 1] !== diff) return false;

  minDiff = Math.min(minDiff, arr[i] - arr[i - 1]);

const candidate1 = nums[n-1] * nums[n-2] * nums[n-3];
const candidate2 = nums[0] * nums[1] * nums[n-1];

  if (i === 0 || sorted[i] < sorted[i - 1]) rank = i + 1;
  if (rank <= cutOffRank) count++;

  if (nums[nums.length - i - 1] !== nums[nums.length - i]) steps += i;

  best = Math.min(best, pos[i + k - 1] - pos[i] + 1);

  if (current[i] !== sorted[i]) {
    const j = indexOf.get(sorted[i]);
    indexOf.set(current[i], j);
    indexOf.set(sorted[i], i);
    [current[i], current[j]] = [current[j], current[i]];
    swaps++;
  }

  const gap = cut - prev;
  if (gap > maxRowGap) maxRowGap = gap;
  prev = cut;

  if (subsetSum > total - subsetSum) break;

  best = Math.min(best, entries[n - 1 - (maxReplacement - i)] - entries[i]);

  if (sorted[i] - sorted[i - 1] !== diff) return false;

  sum += sorted[i];

RETURN

return result

return false;

return true;

return result;

return Math.max(candidate1, candidate2);

return count;

return steps;

return best;

return swaps;

return maxRowGap * maxColGap;

subset.sort((a, b) => a - b);
return subset;

return best;

return true;

return sum / m;