0xD34F

Формулировка вопроса какая-то расплывчатая. Непонятно, о каком количестве повторяющихся элементов идёт речь - взятых в единственном экземпляре, или с учётом повторений. Т.е., каким должен быть результат для, например, такого массива - [ 7, 7, 7, 0, 1, 1 ]? В первом случае 2 - повторяются семёрка и единица, во втором 5 - три семёрки плюс две единицы.

Количество уникальных дубликатов:

const duplicateCount = Object
  .values(arr.reduce((acc, n) => (acc[n] = (acc[n] || 0) + 1, acc), {}))
  .filter(n => n > 1)
  .length;

// или

const duplicateCount = Array
  .from(arr.reduce((acc, n) => acc.set(n, acc.has(n)), new Map).values())
  .reduce((acc, n) => acc + n, 0);

// или

const duplicateCount = new Set(arr.filter((n, i, a) => i !== a.indexOf(n))).size;

С учётом повторений:

const duplicateCount = Object
  .values(arr.reduce((acc, n) => (acc[n] = acc.hasOwnProperty(n), acc), {}))
  .reduce((acc, n) => acc - !n, arr.length);

// или

const duplicateCount = Array
  .from(arr.reduce((acc, n) => acc.set(n, -~acc.get(n)), new Map).values())
  .reduce((acc, n) => acc + (n > 1) * n, 0);

// или

const duplicateCount = arr
  .filter((n, i, a) => a.indexOf(n) !== a.lastIndexOf(n))
  .length;

foreach ($arr as $el) {
  $grouped[explode('/', $el)[2]][] = $el;
}

max(array_map(function($n) {
  return $n['ask']['c'];
}, $obj['candles']))

или

max(array_column(array_column($obj['candles'], 'ask'), 'c'))

Сначала подумал что можно рандомизированный массив засунуть в set...

Надо наоборот - сначала set, потом массив:

function randomArr(length, min, max) {
  const values = new Set;
  while (values.size < length) {
    values.add((Math.random() * (max - min + 1) | 0) + min);
  }
  return [...values];
}


const arr = randomArr(40, 1, 100);

Но вообще, есть и другие методы.

Например, можно создать массив со всеми возможными значениями, и выдёргивать из него элементы случайным образом, сколько надо:

function randomArr(length, min, max) {
  const arr = Array.from({ length: max - min + 1 }, (n, i) => i + min);
  return Array.from({ length }, () => arr.splice(Math.random() * arr.length | 0, 1)[0]);
}

Или, создать массив со всеми возможными значениями, перемешать его, взять из начала сколько надо элементов:

function randomArr(length, min, max) {
  const arr = Array.from({ length: max - min + 1 }, (n, i) => i + min);

  for (let i = arr.length; --i > 0; ) {
    const j = Math.random() * (i + 1) | 0;
    [ arr[j], arr[i] ] = [ arr[i], arr[j] ];
  }

  return arr.slice(0, length);
}

Сделаем функцию, которая нарезает массив на куски указанного размера:

const getChunks = (arr, chunkSize) =>
  Array.from(
    { length: Math.ceil(arr.length / chunkSize) },
    (n, i) => arr.slice(i * chunkSize, (i + 1) * chunkSize)
  );

// или

const getChunks = (arr, chunkSize) =>
  arr.reduce((acc, n, i) => (
    i = i / chunkSize | 0,
    (acc[i] = acc[i] || []).push(n),
    acc
  ), []);

// или

const getChunks = (arr, chunkSize) =>
  arr.reduce((acc, n, i) => (
    (i % chunkSize) || acc.push([]),
    acc[acc.length - 1].push(n),
    acc
  ), []);

Ну и воспользуемся ею:

const arr = [...Array(50).keys()];
const chunks = getChunks(arr, 7);

$ids = array_map(function($n) {
  return array_values($n)[0];
}, $array2);

$array1 = array_filter($array1, function($n) use($ids) {
  return in_array($n['id'], $ids);
});

const arr = [
  [ 2, 7, 2 ],
  [ 2, 5, 4 ],
  [ 2, 1, 5 ],
  [ 3, 1, 2 ],
];

const [ val, iRow, iCol ] = arr
  .map((n, i) => n.reduce((min, m, j) => min[0] <= m ? min : [ m, i, j ], [ Infinity, -1 ]))
  .reduce((min, n) => min[0] <= n[0] ? min : n);

UPD. Если нужно обрабатывать массивы произвольной размерности, можно применить рекурсию:

const arr = [
  [ 2, 7, 2, [ 5, [ 4, [ 3 ], 2 ] ] ],
  [ 2, 5, [ 2, 6, 5, 2 ], 4 ],
  [ 2, 1, [ [ [ 9, 0, 1 ], [ [ [ 1 ] ] ], -1 ] ], 5 ],
  [ 3, 1, 2 ],
];

const minElemWithIndex = arr =>
  arr.reduce((min, n, i) => {
    const m = n instanceof Array
      ? minElemWithIndex(n)
      : [ n, [] ];

    m[1].unshift(i);

    return m[0] < min[0] ? m : min;
  }, [ Infinity, [] ]);


const [ val, indices ] = minElemWithIndex(arr);

Ну, как-то так, например:

$arr = eval("return $str;");

$str - это ваша строка из БД.

function createArr(size) {
  const arr = [...Array(size)].map(() => Array(size).fill(0));

  const mid = (size / 2) | 0;
  arr.forEach((n, i) => {
    n[i] = n[size - i - 1] = 1;
    // если размер чётный, непонятно, где выставлять единицы, так что выставляем только для нечётных
    if (size & 1) {
      arr[mid][i] = n[mid] = 1;
    }
  });
  // хотя, конечно, есть вариант ставить по два вертикальных и горизонтальных ряда единиц
  /*
  const mid = (size - 1) / 2;
  arr.forEach((n, i) =>
    n[i] =
    arr[mid | 0][i] =
    arr[Math.ceil(mid)][i] =
    n[mid | 0] =
    n[Math.ceil(mid)] =
    n[size - i - 1] =
  1);
  */

  return arr;
}

Оценить результат работы можно так, например:

console.log(createArr(21).map(n => n.join('')).join('\n'));

Выведет такое вот чудище:

100000000010000000001
010000000010000000010
001000000010000000100
000100000010000001000
000010000010000010000
000001000010000100000
000000100010001000000
000000010010010000000
000000001010100000000
000000000111000000000
111111111111111111111
000000000111000000000
000000001010100000000
000000010010010000000
000000100010001000000
000001000010000100000
000010000010000010000
000100000010000001000
001000000010000000100
010000000010000000010
100000000010000000001