Handling Edge Cases

function processArray(arr) {
  if (arr === null || arr === undefined) {
    return [];
  }
  return arr.map(x => x * 2);
}

// Example usage
console.log(processArray(null)); // []
console.log(processArray([1, 2, 3])); // [2, 4, 6]

function processItems(items = []) {
  if (items.length === 0) {
    console.log("No items to process");
    return;
  }

  for (let i = 0; i < items.length; i++) {
    console.log(items[i]);
  }
}

const nums = [1, 2, 2, 3, 4, 4, 5];
const unique = [...new Set(nums)];
console.log(unique); // [1, 2, 3, 4, 5]

const nums = [1, 2, 2, 3, 4, 4, 5];
const countMap = new Map();
nums.forEach(num => {
  countMap.set(num, (countMap.get(num) || 0) + 1);
});
const duplicates = [...countMap.entries()]
  .filter(([_, count]) => count > 1)
  .map(([num, _]) => num);
console.log(duplicates); // [2, 4]

const numbers = [1, -2, 3, -4, 5];\nconst negatives = numbers.filter(n => n < 0);\nconsole.log(negatives); // [-2, -4]

public static int addWithOverflowCheck(int a, int b) {
    if (a > Integer.MAX_VALUE - b) {
        throw new ArithmeticException("Integer overflow");
    }
    return a + b;
}

func safeAdd(a, b int) (int, error) {
    if a > math.MaxInt32-b {
        return 0, fmt.Errorf("integer overflow")
    }
    return a + b, nil
}

function floatEquals(a, b, epsilon = 1e-9) {
  return Math.abs(a - b) <= epsilon;
}

const x = 0.1 + 0.2;
console.log(floatEquals(x, 0.3)); // true

function roundToDecimalPlaces(num, decimals) {
  const factor = Math.pow(10, decimals);
  return Math.round((num + Number.EPSILON) * factor) / factor;
}

const result = roundToDecimalPlaces(0.1 + 0.2, 10);
console.log(result); // 0.3

const tree = {
  value: 1,
  children: [
    { value: 2, children: [] },
    { value: 3, children: [{ value: 4, children: [] }] }
  ]
};

// Create circular reference
tree.children[0].parent = tree;

function detectCycle(node, visited = new Set()) {
  if (visited.has(node)) return true;
  visited.add(node);
  for (let child of node.children) {
    if (detectCycle(child, visited)) return true;
  }
  return false;
}

console.log(detectCycle(tree)); // true

function validateInput(input) {
  if (input === null || input === undefined) {
    throw new Error('Input cannot be null or undefined');
  }
  if (typeof input === 'string' && input.trim() === '') {
    throw new Error('Input cannot be an empty string');
  }
  if (typeof input === 'number' && isNaN(input)) {
    throw new Error('Input must be a valid number');
  }
  return true;
}

function chunkArray(array, size) {
  const chunks = [];
  for (let i = 0; i < array.length; i += size) {
    chunks.push(array.slice(i, i + size));
  }
  return chunks;
}

const largeArray = Array.from({ length: 1000 }, (_, i) => i);
const chunked = chunkArray(largeArray, 100);
console.log(chunked.length); // 10

const normalizeLineEndings = (text) => {
  return text.replace(/\r\n?/g, '\n');
};

const input = "Line1\r\nLine2\rLine3\nLine4";
console.log(normalizeLineEndings(input));
// Output: "Line1\nLine2\nLine3\nLine4"

const specialChars = {
  quote: "He said, \"Hello!\"",
  newline: "Line1\nLine2",
  tab: "Column1\tColumn2"
};

const json = JSON.stringify(specialChars);
console.log(json);
// Output: "{\"quote\":\"He said, \\\\\\"Hello!\\\\\\"\",\"newline\":\"Line1\\\\nLine2\",\"tab\":\"Column1\\\\tColumn2\"}"

let counter = 0;
let lock = false;

function safeIncrement() {
  while (lock) {} // Busy wait
  lock = true;
  counter++;
  lock = false;
}