Code Review (Warmup): Dead Code (Zombie Code)

← Back to Difficulty Selection

Code Review (Warmup): Dead Code (Zombie Code)

Story

This function isn't called.

This variable isn't used.

But it's still here just in case.

Dead code makes the codebase heavier and harder to read.

Developers spend time understanding logic that never runs, only to discover it doesn't matter at all.

Rule of thumb:

If it's not used, it's not helping.

Next Topic: Inconsistent Naming Conventions

export function threeSumClosest(nums: number[], target: number): number {
  const n = nums.length;
  if (n < 3) throw new Error("nums must have at least 3 elements");
  nums.sort((a, b) => a - b);
  let closestSum = nums[0] + nums[1] + nums[2];
  for (let i = 0; i < n - 2; i++) {
    let left = i + 1;
    let right = n - 1;
    while (left < right) {
      const sum = nums[i] + nums[left] + nums[right];
      if (Math.abs(sum - target) < Math.abs(closestSum - target)) {
        closestSum = sum;
      }
      if (sum === target) return target;
      if (sum < target) {
        left++;
      } else {
        right--;
      }
    }
  }
  return closestSum;
}

/*
function previousThreeSumClosest(nums: number[], target: number): number {
  // older version kept for reference
  nums = nums.slice();
  nums.sort((a, b) => a - b);
  let best = Infinity;
  for (let i = 0; i < nums.length - 2; i++) {
    for (let j = i + 1; j < nums.length - 1; j++) {
      for (let k = j + 1; k < nums.length; k++) {
        const s = nums[i] + nums[j] + nums[k];
        if (Math.abs(s - target) < Math.abs(best - target)) {
          best = s;
        }
      }
    }
  }
  return best === Infinity ? 0 : best;
}
*/

type Triplet = [number, number, number];

class ThreeSumHelper {
  private data: number[];
  constructor(nums: number[]) {
    this.data = nums.slice();
  }

cloneData(): number[] {
    return this.data.slice();
  }

// Not used: alternative sort strategy that someone might try later
  stableSort() {
    // stable sorting by pairing with indices
    const paired = this.data.map((v, i) => ({ v, i }));
    paired.sort((a, b) => (a.v === b.v ? a.i - b.i : a.v - b.v));
    this.data = paired.map(p => p.v);
  }

// Not used: returns all unique triplets (for debugging)
  findAllTriplets(): Triplet[] {
    const res: Triplet[] = [];
    const n = this.data.length;
    if (n < 3) return res;
    const arr = this.data.slice().sort((a, b) => a - b);
    for (let i = 0; i < n - 2; i++) {
      let l = i + 1;
      let r = n - 1;
      while (l < r) {
        const sum = arr[i] + arr[l] + arr[r];
        res.push([arr[i], arr[l], arr[r]]);
        l++;
        r--;
      }
    }
    return res;
  }
}

const DEFAULT_CHECK_LIMIT = 1000;
const UNUSED_FLAG = false;