Поиск и подсчет, сколько раз конкретная команда появляется в массиве

Question

Я искал и ничего не нашел. Вот как выглядит мой тестовый пример:

console.log(specificSearch([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
  ], 'even')); // the maximum number of even numbers is in row - 2, which are 2 and 8

  console.log(specificSearch([
  ['o', 'o', 'o', 'x'],
  ['x', 'x', 'o'],
  ['o', 'x'],
  ['x', 'x', 'x', 'x', 'x', 'x', 'x']
  ], 'x')); // the maximum number of x is in column - 4, which is 7 times appear

и это мой код:

function specificSearch(array, command) {

    var max = 0
    var even = 0
    for(var i = 0; i < array.length; i++){
      var evenCounter = 0
       for(var j = 0; j < array[i].length; j++){
          if(command === 'even'){
             if(array[i][j] % 2 == 0){
                evenCounter++
             }
          } 
       }

       if(command === 'even' ){
         if( max < evenCounter) {
           max = evenCounter
           even = i
         }
       }
    }
    return even
  }

вот когда я пытаюсь найти четное число, если оно ищет номер, то оно должно возвращаться в строке и какое число, но, с другой стороны, если оно не ищет номер, а длина массива не совпадает, то нужно возвращать в какой столбец и сколько раз появляется. В этом случае не требуется встроенная функция, такая как регулярное выражение, карта, фильтр, индекс, просто используйте циклы и операции с массивами, такие как push, pop, shift и т. Д.

Спасибо за вашу помощь, я просто нуб, который пытается выучить код:)

Answer 1

Вы можете передать функцию для проверки определенного значения и вернуть логическое значение для проверки.

• для even дубль

  x => !(x % 2)`
  

• для проверки личности взять

  x => x === 'x'
  

Затем вы можете собрать все значения в массивах строк и столбцов, а затем получить максимальное значение и получить из rows / cols массив индексов с максимальным значением.

Результатом является объект с максимальным количеством строк / столбцов и индексами, где происходит максимальное количество.

Кстати, в этом ответе индексы работают так, как они работают в Javascript, начиная с нуля. Если вам нужно начать с одного, просто добавьте один к каждому индексу.

function specificSearch(array, checkFn) {

    function getIndices(array, value) {
        var i, indices = [];
        for (i = 0; i < array.length; i++) {
            if (array[i] === value) indices.push(i);
        }
        return indices;
    }

    var i, j,
        rows = [],
        cols = [],
        max;

    for (i = 0; i < array.length; i++) {
        for (j = 0; j < array[i].length; j++) {
            if (checkFn(array[i][j])) {
                rows[i] = (rows[i] || 0) + 1;
                cols[j] = (cols[j] || 0) + 1;
            }
        }
    }
    max = Math.max(...cols, ...rows);
    return { max, rows: getIndices(rows, max), cols: getIndices(cols, max) };
}

console.log(specificSearch([[1, 2, 3], [4, 5, 6], [7, 8, 9]], x => !(x % 2)));
console.log(specificSearch([['o', 'o', 'o', 'x'], ['x', 'x', 'o'], ['o', 'x'], ['x', 'x', 'x', 'x', 'x', 'x', 'x']], x => x === 'x'));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

В этом случае не требуется встроенная функция

Обычно, когда вы хотите превратить массив в одно значение, вы используете Array.prototype.reduce

const specificSearch = (array, comparer) =>
  array.reduce((highest, items) => {
    //reduce to highest number
    const current = items.reduce(
      //reduce to number
      //if comparer returns true for item add 1 to sum
      (sum, item) => (comparer(item) ? sum + 1 : sum),
      0,//start with sum of 0
    );
    //if current result is higher than highest so far
    //  return current, else return highest
    return current > highest ? current : highest;
  }, 0/** start with highest value of 0 */);

console.log(
  "max times even in item array",
  specificSearch(
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
    (x) => x % 2 === 0,
  ),
);

console.log(
  "max times value of 'x' in item array",
  specificSearch(
    [
      ['o', 'o', 'o', 'x'],
      ['x', 'x', 'o'],
      ['o', 'x'],
      ['x', 'x', 'x', 'x', 'x', 'x', 'x'],
    ],
    (x) => x === 'x',
  ),
);

Если вы увидите фрагмент кода, то вы заметите, что можно превратить массив в число с внутренним уменьшением, а внешнее сокращение выбирает наибольшее число.

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