Fedor Vlasenko

arr.reduce((acc, n) => (
  n = n.match(/(\S+) = (.*)/),
  n && (acc[n[1]] = n[2]),
  acc
), {})

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');

const getValue = (obj, keys) => keys.reduce((acc, key) => acc?.[key], obj);

const result = [];
for (let i = 1; i < t.length; i += 2) {
  const sub = [];
  for (j = 0; j < t[0].length; j += 1) {
    sub.push([t[0][j], t[i][j], t[i + 1][j]]);
  }
  result.push(sub);
}
console.log(result);

Коротко:

const getRepetition = (arr, repeated) => Array
  .from(arr.reduce((acc, n) => acc.set(n, -~acc.get(n)), new Map))
  .reduce((acc, n) => (n[1] === repeated && acc.push(n[0]), acc), []);

Длинно:

function getRepetition(arr, repeated) {
  const result = [];
  const count = {};

  for (const n of arr) {
    if (!count.hasOwnProperty(n)) {
      count[n] = 0;
    }

    count[n]++;
  }

  for (const n in count) {
    if (count[n] === repeated) {
      result.push(+n);
    }
  }

  return result;
}

const merge = (key, ...arrs) =>
  Object.values(arrs.flat().reduce((acc, n) => (
    Object.assign(acc[n[key]] ??= {}, n),
    acc
  ), {}));


const result = merge('id', arr1, arr2, arr3);

https://golang.org/doc/effective_go
https://github.com/cristaloleg/go-advice
https://dave.cheney.net/practical-go/
https://github.com/golang/go/wiki/CodeReviewComments
https://github.com/golang/go/wiki/SliceTricks

Еще полезно поизучать крупные опенсурсные проекты на Github

Вспомните алгоритм преобразования числа из 10-чной системы в t-ичную - надо делить на t с остатком, пока есть что делить. Остатки - цифры в t-ичной системе счисления (от младших к старшим).

Так, 323 в десятичной системе, если перевести в 16-ричную будет:
323 = 16*20+3. Остаток 3, результат 20.
20 = 16*1+4. Остаток 4, результат 1
1 = 16*0+1. Остаток 1. результат 0.

Отсюда получается, что искомое число в 16-ричной системе 143. Проверка 16*16*1+16*4+3 = 256+64+3=323

Итак, вам надо сделать то же самое, но не в 10-чиной системе, а в k-ичной (ведь переводим не из 10-чной а из k-ичной). Число записано в виде k-ичных цифр в массиве. Это, фактически, длинная арифметика с базой k.

Для этого надо реализовать деление числа в виде массива цифр на короткое с остатком.
Это делается со старших разрядов к младшим. Тупо делите каждую цифру с остатком отдельно. Остаток переносите в младший разряд. Последний остаток - это остаток от всего деления. Результаты делений - новые цифры.

Удобнее хранить цифры от младших к старшим в массиве. Т.е. элемент массива 0 - это единицы. Элемент 1 - это первая степень k. Еще стоит хранить номер последней ненулевой цифры. Смотрите реализацию по ссылке выше.

Вот пример из условия. Пусть k=666, t=10, число - {2, 179, 113} (в условии цифры от старших к младшим, но мы храним наоборот).

Делим на 10.

113/10 = 11 + остаток 3. Переносим 3 в младший разряд (умножив на 666), получаем 3*666+179=2177.
2177 / 10 = 217 + остаток 7. 7*666+2 = 4664.
4664 /10 = 466 + остаток 4. Дальше разрядов нет, значит 4 и есть остаток от деления {2, 179, 113} на 10. Результат деления - {466, 217, 11}

Последний остаток - 4 - это и есть младшая цифра в ответе (он в условии написан - 50241044). Надо продолжать делить результат пока он не окажется 0.

Повторим для {466, 217, 11}:
11/10 = 1 + остаток 1. 1*666+217 = 883
883/10 = 88 + остаток 3. 3*666+446 = 2444
2444/10 = 244 + остаток 4.
Опять, последний остаток - это остаток всего деления и следующая цифра в ответе (опять 4).
Результаты деления - {244, 88, 1}

И так далее, пока все число не станет 0 (все цифры в массиве 0).