0xD34F

Сколько свойств должно быть в объекте: const propsCount = 3;.

Собираем новый объект:

const newObj = Object.fromEntries(Object
  .entries(obj)
  .sort((a, b) => a[1] - b[1])
  .slice(-propsCount)
);

Удаляем свойства существующего:

Object
  .entries(obj)
  .sort((a, b) => b[1] - a[1])
  .slice(propsCount)
  .forEach(n => delete obj[n[0]]);

str.match(/(?<=>)\d+/g) ?? []

// или

str.match(/>\d+/g)?.map(n => n.slice(1)) ?? []

// или

Array.from(str.matchAll(/>(\d+)/g), n => n[1])

''.concat(...Array.from(str, n => n.repeat(2)))
// или
str.replace(/./g, '$&$&')
// или
str.replace(/./g, m => Array(3).join(m))
// или
str.replace(/(?=.)/g, (m, i) => str[i])
// или
[...str].flatMap(n => Array(2).fill(n)).join('')
// или
[].map.call(str, n => `${n}${n}`).join``
// или
str.split('').reduce((acc, n) => acc + n + n, '')

Сложить объекты в массив, и

const averageAge = arr.reduce((acc, n) => acc + n.age, 0) / arr.length;

Это если делать просто и ровно то, что спрошено. Но можно решить задачу и в более общем виде - сделаем функцию, вычисляющую среднее передаваемого ей итерируемого объекта:

function avg(data, key = n => n) {
  const getVal = key instanceof Function ? key : n => n[key];
  let sum = 0;
  let count = 0;

  for (const n of data) {
    sum += getVal(n);
    count += 1;
  }

  return sum / count;
}

В вашем случае применять так: const averageAge = avg(arr, 'age');.

Другие варианты использования:

avg(Array(10).keys()) // 4.5
avg('12345', Number) // 3
avg(document.images, n => n.width) // сами посмотрите, сколько тут получится

arr.reduce((acc, n, i) => (
  (!i || n === 1) && acc.push([]),
  acc[acc.length - 1].push(n),
  acc
), [])

Если надо изменить одно слово с минимальной длиной:

const index = arr.reduce((min, n, i, a) => a[min]?.length <= n.length ? min : i, -1);
if (index !== -1) {
  arr[index] = arr[index][0].toUpperCase() + arr[index].slice(1);
}

Если слов с минимальной длиной может быть несколько и надо изменить все:

const [ indexes ] = arr.reduce((min, n, i) => (
  n.length < min[1] && (min = [ [], n.length ]),
  n.length === min[1] && min[0].push(i),
  min
), [ [], Infinity ]);

indexes.forEach(n => arr[n] = arr[n].replace(/./, m => m.toUpperCase()));

const date = new Date(str.replace(/\S+/, m => m.split('.').reverse().join('-')));

или

const date = new Date(str.replace(/(\d+)\.(\d+)\.(\d+)/, '$3-$2-$1'));

или

const [ day, month, year, hours, minutes, seconds ] = str.split(/\D/);
const date = new Date(year, month - 1, day, hours, minutes, seconds);

или (day.js):

const date = dayjs(str, 'DD.MM.YYYY HH:mm:ss').toDate();

function sort([...arr]) {
  const max = arr.reduce((max, n) => max?.population > n.population ? max : n, null);
  return arr.sort((a, b) => a === max ? -1 : b === max ? 1 : a.city.localeCompare(b.city));
}

О каком классе идёт речь: const className = 'model';

Как получить элементы:

const elements = document.querySelectorAll(`.${className}`);
// или
const elements = document.getElementsByClassName(className);

Как извлечь из элемента его текст:

const getText = el => el.textContent;
// или
const getText = el => el.innerText;
// или
const getText = el => el.innerHTML;
// или
const getText = el => el.lastChild.nodeValue;
// или
const getText = el => el.childNodes[0].data;

Перебираем элементы, достаём тексты, склеиваем:

const result = Array.from(elements, getText).join(', ');

// или

const result = ''.concat(...[...elements].flatMap((n, i) => (
  n = getText(n),
  i ? [ ', ', n ] : n
)));

// или

const result = Array.prototype.reduce.call(
  elements,
  (acc, n, i) => acc + (i ? ', ' : '') + getText(n),
  ''
);

// или

const result = (function get(i, n = elements[i]) {
  return n
    ? `${i ? ', ' : ''}${getText(n)}${get(i + 1)}`
    : ''
})(0);

Вот reduce:

const { x: countX = 0, o: countO = 0 } = Array
  .from(str.toLowerCase())
  .reduce((acc, n) => (acc[n] = (acc[n] ?? 0) + 1, acc), {});

А вот ещё короче без reduce'а:

const [ countX, countO ] = [ /x/i, /o/i ].map(n => ~-str.split(n).length);

В заголовке вопроса:

найти объект

В тексте:

найти самое большое значение

Ну и как это понимать? Сами-то в курсе, чего вам надо?

Первое:

const obj = arr.flat().reduce((max, n) => max?.age > n.age ? max : n, null);

Второе:

const val = Math.max(...arr.flat().map(n => n.age));

Кстати, а что если максимум представлен в нескольких экземплярах? Можно получить все такие объекты:

const objs = arr.reduce((acc, n) => (
  n.forEach(m => (
    m.age > acc[0] && (acc = [ m.age, [] ]),
    m.age === acc[0] && acc[1].push(m)
  )),
  acc
), [ -Infinity, [] ])[1];

Собираем ключ-значение, выдёргиваем значения:

[...new Map(arr.map(n => [ n.value, n ])).values()]

// или

Object.values(arr.reduce((acc, n) => (acc[n.value] ??= n, acc), {}))

Фильтрация, запоминаем кого встретили, первый раз пропускаем, остальные нет:

arr.filter(function(n) {
  return !(this[n.value] = this.hasOwnProperty(n.value));
}.bind({}))

// или

arr.filter(function({ value }) {
  return !this.set(value, this.has(value)).get(value);
}, new Map)

// или

arr.filter(((picked, { value: n }) => !picked.has(n) && picked.add(n)).bind(null, new Set))

Фильтрация, ищем элемент похожий на текущий, его же и нашли - окей:

arr.filter((n, i, a) => n === a.find(m => m.value === n.value))

// или

arr.filter((n, i, a) => i === a.findIndex(m => Object.is(m.value, n.value)))

Ну и чего-нибудь странного ещё добавим:

Array.from(
  new Set(arr.map(n => n.value)),
  n => arr.find(m => m.value === n)
)

// или

arr
  .slice()
  .sort((a, b) => a.value.localeCompare(b.value))
  .filter((n, i, a) => n.value !== a[i - 1]?.value)

Собрать новый массив:

const newArr = Array
  .from(arr.reduce((acc, n) => acc.set(n, (acc.get(n) ?? 0) + 1), new Map))
  .filter(n => n[1] === 1)
  .map(n => n[0]);

Обновить существующий:

arr.splice(0, arr.length, ...Array
  .from(arr.reduce((acc, n) => acc.set(n, acc.has(n)), new Map))
  .reduce((acc, n) => (n[1] || acc.push(n[0]), acc), [])
);

Знаю, что можно сделать с помощью split и прочими способами,...

Если знаете - почему не показали? Никакой split не нужен:

str.slice(0, -3).replace(',', '')

Конечно, если очень хочется, то нет проблем его использовать:

str.split(':', 2).join(':').split(',').join('')

...но нужно элегантное решение

В данном случае оно может таким быть (или, по крайней мере, таким казаться):

str.replace(/,|.{3}$/g, '')

Но вообще, регулярные выражения - это не синоним элегантного решения:

str.replace(/(\d+.\d+.\d+)..(\d+.\d+).*/, '$1 $2')

Math.max(0, ...arr.reduce((acc, n, i, a) => (
  n !== a[i - 1] && acc.push(0),
  acc[acc.length - 1]++,
  acc
), []))

или

arr.reduce((acc, n, i, a) => (
  n !== a[~-i] && (acc[1] = 0),
  acc[0] = acc[+(++acc[1] > acc[0])],
  acc
), [ 0, 0 ])[0]

for (let i = 1; i < arr.length; i++) {
  if (arr[i] === arr[i - 1]) {
    for (let j = i--; ++j < arr.length; arr[j - 1] = arr[j]) ;
    arr.pop();
  }
}

или

arr.reduceRight((_, n, i, a) => i && n === a[i - 1] && a.splice(i, 1), null);

или

arr.splice(0, arr.length, ...arr.filter((n, i, a) => !i || a[i - 1] !== n));

или

arr.length -= arr.reduce((acc, n, i, a) => (
  a[i - acc] = n,
  acc + (i && n === a[i - 1 - acc])
), 0);

Object.values(arr.reduce((acc, { category, ...n }) => (
  (acc[category.id] ??= { ...category, tanks: [] }).tanks.push(n),
  acc
), {}))

Сортируем существующий массив:

function sort(arr, order, key = n => n) {
  const positions = new Map(order.map((n, i) => [ n, i ]));
  const getPosition = n => positions.get(key(n)) ?? Number.MAX_SAFE_INTEGER;
  return arr.sort((a, b) => getPosition(a) - getPosition(b));
}

Собираем отсортированный новый:

function sorted(arr, order, key = n => n) {
  const ordered = new Map(order.map(n => [ n, [] ]));
  const unordered = [];
  arr.forEach(n => (ordered.get(key(n)) ?? unordered).push(n));
  return [].concat(...ordered.values(), unordered);
}

Примеры использования:

a1 = [ '999', '290', '999', '222', '333', '987', '309', '666', '999' ];
a2 = [ '999', '222', '666' ];
sorted(a1, a2) // [ '999', '999', '999', '222', '666', '290', '333', '987', '309' ]


a1 = [ 12, 34, 6, 2, 55, 523, 23, 333, 16, 51 ];
a2 = [ 3, 5, 2 ];
sorted(a1, a2, n => +`${n}`[0]) // [ 34, 333, 55, 523, 51, 2, 23, 12, 6, 16 ]


a1 = [ 666, 'xxx', () => [], true, 1, () => null, false, 'aaa', [0] ];
a2 = [ 'boolean', 'string', 'function' ];
sort(a1, a2, n => typeof n);
a1 // [ true, false, 'xxx', 'aaa', () => [], () => null, 666, 1, [ 0 ] ]

.active {
  background: red;
}

document.querySelector('table').addEventListener('change', ({ target: t }) => {
  t.closest('tr').classList.toggle('active', t.checked);
});

// или

document.querySelectorAll('table tr').forEach(function(n) {
  n.addEventListener('change', this);
}, e => e.currentTarget.classList.toggle('active', e.target.checked));

UPD. Наконец-то дождались, js теперь тут не нужен:

tr:has(.form-check-input:checked) {
  background: red;
}

const names = Array.from(
  document.querySelectorAll('#mainTable input:checked'),
  n => n.name
);

или

const names = Array.prototype.reduce.call(
  document.getElementById('mainTable').getElementsByTagName('input'),
  (acc, n) => (n.checked && acc.push(n.getAttribute('name')), acc),
  []
);