Как найти одинаковые значения рядом друг с другом в многомерном массиве?

Question

Я попытался написать функцию, которая находила бы в многомерном массиве (со значениями от 3 до 7) повторяющиеся значения по крайней мере 3 раза рядом друг с другом (вертикальный и горизонтальный).И если он обнаружит это, измените его на другое значение.Допустим, 1.

Я пытался сделать это с помощью циклов, но это не похоже на хороший способ решить эту проблему, или я все испортил.Потому что для некоторых массивов это работает, для некоторых - нет.

Вот мой код:

function searching(array) {
  for (i = 0; i < array.length; i++) {
    let horizontal = array[i][0];
    let howMany = 1;

    for (j = 1; j < array[i].length; j++) {
      if (horizontal === array[i][j]) {
        howMany += 1;
        horizontal = array[i][j];
        if (howMany >= 3) {
          for (d = j; d > j - howMany; d--) {
            array[i][d] = 0;
          }
        }
      } else {
        horizontal = array[i][j];
        howMany = 1;
      }

    }

  }


  for (v = 0; v < array.length; v++) {
    let vertical = array[0][v];
    let howMany = 1;
    for (x = 1; x < array.length; x++) {
      if (vertical === array[x][v]) {
        howMany++;
        vertical = array[x][v];
        if (howMany >= 3) {
          for (d = x; d > x - howMany; d--) {
            array[d][v] = 0;
          }
        }
      } else {
        vertical = array[x][v];
        howMany = 1;
      }
    }
  }
}

Идея состоит в том, чтобы, например, дать массив:

let array = [
    [3, 4, 5, 6, 7],
    [3, 4, 5, 6, 7],
    [3, 4, 5, 5, 5],
    [3, 5, 6, 7, 4]
  ]

И результат должен быть:

let result = [
    [1, 1, 1, 6, 7],
    [1, 1, 1, 6, 7],
    [1, 1, 1, 1, 1],
    [1, 5, 6, 7, 4]
  ]

Заранее спасибо за любые идеи, как решить эту проблему :) Привет!

Answer 1

Проблемы с вашим текущим кодом:

(1) Вы проверяете только отдельные строки и столбцы, когда вам нужно проверять их оба (например, с [[2, 2], [2, 5]], когда в начальной позиции[0][0], вам нужно посмотреть как [0][1] (и его соседей, если они совпадают), так и [1][0] (и его соседей, если они совпадают).

(2) Вы на самом деле непроверяя смежность в данный момент, вы просто подсчитываете общее количество совпадающих элементов в конкретной строке или столбце.

Перебор всех указателей массива. Если индекс уже проверен, вернитесь раньшеРекурсивно ищите соседей по этому индексу, и, если найдено как минимум 3 совпадающих, установите их всех равными 1. Поместите всех подходящих соседей в набор checked, чтобы избежать их повторной проверки (даже если их было меньше 2 смежных).всего найдено совпадений).

setAllAdjacentToOne([
  [3, 4, 5, 6, 7],
  [3, 4, 5, 6, 7],
  [3, 4, 5, 5, 5],
  [3, 5, 6, 7, 4]
]);
// all 9s stay, the rest get set to 1:
setAllAdjacentToOne([
  [2, 2, 9, 7, 7],
  [2, 9, 9, 9, 7],
  [3, 4, 4, 5, 5],
  [9, 4, 5, 5, 9]
]);


function setAllAdjacentToOne(input) {
  const output = input.map(subarr => subarr.slice());
  const checked = new Set();
  const getKey = (x, y) => `${x}_${y}`;

  const width = input[0].length;
  const height = input.length;
  const getAllAdjacent = (x, y, numToFind, matches = []) => {
    if (x >= width || x < 0 || y >= height || y < 0) {
      return matches;
    }
    const key = getKey(x, y);
    if (!checked.has(key) && input[y][x] === numToFind) {
      checked.add(key);
      matches.push({ x, y });
      getAllAdjacent(x + 1, y, numToFind, matches);
      getAllAdjacent(x - 1, y, numToFind, matches);
      getAllAdjacent(x, y + 1, numToFind, matches);
      getAllAdjacent(x, y - 1, numToFind, matches);
    }
    return matches;
  };

  output.forEach((innerRowArr, y) => {
    innerRowArr.forEach((num, x) => {
      const allAdjacent = getAllAdjacent(x, y, num);
      if (allAdjacent.length <= 2) {
        return;
      }
      allAdjacent.forEach(({ x, y }) => {
        output[y][x] = 1;
      });
    });
  });
  console.log(JSON.stringify(output));
}

Answer 2

Сначала я не понял вопроса ... Так вот мой код:

let array = [
  [3, 4, 5, 6, 7],
  [3, 4, 5, 6, 7],
  [3, 4, 5, 5, 5],
  [3, 5, 6, 7, 4]
];

function replace(arr, target = 1) {
  let needToChange = []; // save the index to change
  const numbers = [3, 4, 5, 6, 7];
  const m = arr.length; // m rows
  const n = arr[0].length; // n columns

  let mi = 0;
  let ni = 0;

  // search in row
  for (mi = 0; mi < m; mi++) {
    for (let x = 0; x < numbers.length; x++) {
      const num = numbers[x]; // number to search
      let counter = 0; // counter for this number in row mi
      let tempArr = [];
      for (ni = 0; ni < n; ni++) {
        const currentNum = arr[mi][ni];
        if (currentNum === num) {
          counter++;
          tempArr.push([mi, ni]);
        }
      }
      if (counter >= 3) {
        needToChange = needToChange.concat(tempArr);
      }
    }
  }

  // search in column
  for (ni = 0; ni < n; ni++) {
    for (let x = 0; x < numbers.length; x++) {
      const num = numbers[x]; // number to search
      let counter = 0; // counter for this number in row mi
      let tempArr = [];
      for (mi = 0; mi < m; mi++) {
        const currentNum = arr[mi][ni];
        if (currentNum === num) {
          counter++;
          tempArr.push([mi, ni]);
        }
      }
      if (counter >= 3) {
        needToChange = needToChange.concat(tempArr);
      }
    }
  }

  // replace
  needToChange.forEach(([i, j]) => {
    array[i][j] = target;
  });
}

replace(array);
array.forEach(row => {
  console.log(row.join(', '));
})