0xD34F

Два раза поиск делайте, отдельно для первого и последнего индексов:

function search(nums, target, searchMin) {
  for (let iMin = 0, iMax = nums.length - 1; iMin <= iMax; ) {
    const index = (iMin + iMax) / 2 | 0;
    const num = nums[index];

    if (num === target && num !== nums[index + (searchMin ? -1 : 1)]) {
      return index;
    } else if (num <= target - (searchMin ? 1 : 0)) {
      iMin = index + 1;
    } else {
      iMax = index - 1;
    }
  }

  return -1;
}

function searchMinMax(nums, target) {
  const iMin = search(nums, target, true);
  return iMin === -1
    ? []
    : [ iMin, search(nums, target, false) ];
}

Считаем повторения символов, приведённых к нижнему регистру, также, встречая символ впервые, запоминаем индекс и оригинальный вид символа (до приведения к нижнему регистру); ищем среди результатов подсчёта повторений такой, который равен единице, и при этом имеет минимально возможный индекс; достаём из найденного оригинальный символ:

const firstNonRepeatingLetter = ([...str]) => Object
  .values(str.reduce((acc, n, i) => ((acc[n.toLowerCase()] ??= [ 0, i, n ])[0]++, acc), {}))
  .reduce((min, n) => (n[0] === 1 && n[1] < min[1] ? n : min), [ 0, Infinity, '' ])
  .pop();

Или. Приводим строку к нижнему регистру; ищем индекс первого уникального символа, т.е. такого, у которого индекс первого вхождения в строку равен индексу последнего вхождения; по найденному индексу извлекаем из исходной строки символ:

const firstNonRepeatingLetter = str =>
  str.charAt(Array
    .from(str.toLowerCase())
    .findIndex((n, i, a) => a.indexOf(n) === a.lastIndexOf(n))
  );

Очевидно, надо написать какой-нибудь другой скрипт.

Объединяем перекрывающиеся интервалы, после объединения суммируем длины:

const sumIntervals = intervals => intervals
  .slice()
  .sort((a, b) => a[0] - b[0])
  .reduce((acc, n) => {
    const top = acc.at(-1);

    if (!top || top[1] < n[0]) {
      acc.push([...n]);
    } else if (top[1] < n[1]) {
      top[1] = n[1];
    }

    return acc;
  }, [])
  .reduce((acc, n) => acc - n[0] + n[1], 0);

Есть такая структура данных - стек называется.

При встрече открывающей скобки добавляем в результирующий массив пару индексов - открывающей и закрывающей скобок. Второе значение, так как закрывающей скобки ещё нет, пока будет null. В стек сохраняем индекс, под которым добавленная пара оказалась в массиве с результатами.

Встретили закрывающую скобку - извлекаем из стека индекс последнего неполного результата, заменяем там null на индекс встреченной скобки. Конечно, если в стеке что-то есть. Если стек пустой - значит, у встреченной закрывающей скобки не было соответствующей ей открывающей, добавляем в результирующий массив пару из null и текущего индекса.

function bracketIndices(str) {
  const stack = [];
  const result = [];

  for (let i = 0; i < str.length; i++) {
    if (str[i] === '{') {
      stack.push(result.push([ i, null ]) - 1);
    } else if (str[i] === '}') {
      if (stack.length) {
        result[stack.pop()][1] = i;
      } else {
        result.push([ null, i ]);
      }
    }
  }

  return result;
}


bracketIndices('{}{{{}}}') // [[0,1],[2,7],[3,6],[4,5]]
bracketIndices('---}{{}{') // [[null,3],[4,null],[5,6],[7,null]]
bracketIndices('fuck off') // []

Используйте стек.

Если, обрабатывая данные, натыкаетесь на объект, надо сохранить в стек текущее состояние - ссылку на копируемые данные, индекс текущего элемента, ссылку на объект, куда копируете; затем установить новое состояние - копируемыми данными будет массив пар ключ-значение встреченного объекта, индекс обнуляется (на самом деле надо выставить -1, нулевое значение будет получено при переходе к следующей итерации; конечно, можно и буквально 0 выставлять, но тогда придётся усложнить работу с индексом - тут увеличиваем, а тут нет), пустой объект в качестве копии.

Если данные закончились, надо восстановить состояние из стека.

Условий, при которых возможно продолжение цикла, будет два - кроме наличия необработанных данных ещё и непустой стек.

function clone(value) {
  const clone = {};
  const stack = [];

  for (
    let i = 0, source = [ [ '', value ] ], target = clone;
    i < source.length || stack.length;
    i++
  ) {
    if (i === source.length) {
      [ i, source, target ] = stack.pop();
    } else {
      const [ k, v ] = source[i];
      const isObject = v instanceof Object;

      target[k] = isObject ? v.constructor() : v;

      if (isObject) {
        stack.push([ i, source, target ]);
        [ i, source, target ] = [ -1, Object.entries(v), target[k] ];
      }
    }
  }

  return clone[''];
}

Или, если в копируемом объекте могут быть циклические ссылки или какой-то из вложенных объектов встречается несколько раз и так же должно быть и в копии, то надо запоминать встреченные объекты, чтобы не обрабатывать их повторно - воспользуемся Map'ом, где ключами будут оригинальные объекты, а значениями их копии.

Как выглядит получение копии объекта: проверяем, встречался ли указанный объект ранее, если нет - создаём новый объект, сохраняем его в Map, а также кладём его вместе с оригиналом в стек, для последующей обработки; достаём из Map'а копию.

Крутим цикл, пока стек не пуст, на каждой итерации достаём из стека объект и его копию, перебираем свойства оригинала, записываем в копию копии значений.

function clone(value) {
  const stack = [];
  const clones = new Map;
  const getClone = val => val instanceof Object
    ? (clones.has(val) || stack.push([ val, clones.set(val, val.constructor()).get(val) ]),
       clones.get(val))
    : val;

  for (getClone(value); stack.length;) {
    const [ source, target ] = stack.pop();
    Object.entries(source).forEach(n => target[n[0]] = getClone(n[1]));
  }

  return getClone(value);
}

как правильнее всего будет это сделать?

Перестать заниматься ерундой и начать использовать готовые решения - structuredClone или cloneDeep, например.

def find_outlier(arr):
  n0, n1, n2 = [ n % 2 for n in arr[:3] ]
  return next(n for n in arr if n % 2 != n0) if n0 == n1 else arr[int(n2 == n0)]

function createTreeFromArray(arr, key, parentKey) {
  const tree = Object.fromEntries(arr.map(n => [ n[key], { ...n } ]));

  return Object.fromEntries(Object.entries(tree).filter(([ , n ]) => {
    return !(tree[n[parentKey]] && ((tree[n[parentKey]].children ??= {})[n[key]] = n));
  }));
}


const tree = createTreeFromArray(arr, 'uid', 'parentUID');

function generator($str, $params) {
  $result = [];

  if (count($params)) {
    $key = key($params);
    $values = is_array($params[$key]) ? $params[$key] : [ $params[$key] ];
    unset($params[$key]);

    foreach ($values as $val) {
      array_push($result, ...generator(str_replace("{{$key}}", $val, $str), $params));
    }
  } else {
    $result[] = $str;
  }

  return $result;
}

Массивы перебираются от конца к началу; цикл крутится до тех пор, пока какой-то из массивов не полностью обработан или имеет место быть переполнение разряда. Сумма разряда - сумма элементов массивов (если массив кончился, то 0) и переполнения предыдущего разряда. Цифра разряда нового числа - младший разряд суммы (т.е., остаток от деления на 10).

function sum(a, b) {
  const result = [];

  for (
    let i = ~-a.length, j = ~-b.length, overflow = 0;
    i >= 0 || j >= 0 || overflow;
    i--, j--
  ) {
    const digit = (a[i] | 0) + (b[j] | 0) + overflow;
    overflow = +(digit > 9);
    result.push(digit % 10);
  }

  return result.reverse();
}

const point = { latitude: lat, longtitude: lon };
const closest = arr.reduce((closest, n) => {
  const d = sphericalDistance(point, n);
  return d < closest[1] ? [ n, d ] : closest;
}, [ null, Infinity ])[0];


function sphericalDistance(p1, p2) {
  // https://en.wikipedia.org/wiki/Great-circle_distance
}

const xxx = ([...str]) => [...new Set(Array.from(
  { length: str.length * 10 },
  (n, i) => str.map((m, j) => (j === (i / 10 | 0)) ? i % 10 : m).join('')
))];

Отсортировать массив, при суммировании в качестве слагаемого брать текущий элемент массива или предыдущее слагаемое + 1, в зависимости от того, кто окажется больше:

const getMinimumUniqueSum = arr => [...arr]
  .sort((a, b) => a - b)
  .reduce((acc, n) => (acc[1] += acc[0] = Math.max(acc[0] + 1, n), acc), [ -Infinity, 0 ])
  .pop();

const addSum = data =>
  (Array.isArray(data) ? data : []).reduce((acc, n) => {
    n.childrenCountSum = addSum(n.children);
    return acc + +n.count + n.childrenCountSum;
  }, 0);

Если происходит перемещение элементов, то счетчик увеличивается на 3, потому что происходит 3 операции с элементами.

А если бы обмен был реализован так:

[ arr[j - 1], arr[j] ] = [ arr[j], arr[j - 1] ];

Или даже так:

swap(arr, j - 1, j); // функция меняет местами элементы, но как именно - вам неизвестно

На сколько бы вы увеличивали счётчик? Не надо 3, пишите 1. Рассматривайте обмен как единую операцию.

function merge(nums1, m, nums2, n) {
  for (let i = m + n, i1 = m - 1, i2 = n - 1; i--;) {
    nums1[i] = i2 < 0 || nums1[i1] > nums2[i2] ? nums1[i1--] : nums2[i2--];
  }
}

Допустим, выведены единица и все двойки: 1, 2, 2 - всего 1 + 2 = 3 числа. А если единица, двойки и все тройки: 1, 2, 2, 3, 3, 3 - всего 1 + 2 + 3 = 6 чисел. Если добавить четвёрки: 1 + 2 + 3 + 4 = 10 чисел. Ну и так далее - это сумма арифметической прогрессии. Если текущее значение счётчика цикла равно сумме натуральных чисел от 1 до текущего выводимого - начинаем выводить следующее число:

const N = чему-то там равно;

for (let i = 1, num = 1; i <= N; i++) {
  console.log(num);
  if (i === (1 + num) * num / 2) {
    num++;
  }
}

UPD. Можно пойти чуть дальше, и вспомнить про квадратные уравнения - в коде выше, в условном операторе, это вот оно. Известно значение счётчика - надо найти число. Так что нет проблем и формулу элемента последовательности вывести:

for (let i = 1; i <= N; i++) {
  console.log(Math.ceil((Math.sqrt(1 + 8 * i) - 1) / 2));
}