Question

我有两个数组-网格和图案

const G = [
  [9,9,9,9,9,9]
]
const P = [
  [9,9]
]

我想让G中所有P都出现。因此输出将是这样的：

[
    {
        line: 0,
        charAtStart: 0,
        charAtEnd: 2,
    },
    {
        line: 0,
        charAtStart: 2,
        charAtEnd: 4,
    },
    {
        line: 0,
        charAtStart: 4,
        charAtEnd: 6,
    },
    {
        line: 0,
        charAtStart: 6,
        charAtEnd: 8,
    },
    {
        line: 0,
        charAtStart: 8,
        charAtEnd: 10,
    }
]

到目前为止我所做的：

for(let i = 0, l = G.length; i < l; i++) {
  if(G[i].toString().includes(P[0].toString())) {

    console.log(G[i].toString(), '\n',
                P[0].toString(), '\n',
                G[i].toString().indexOf(P[0].toString())
               )

    availableFirstLines.push({
      line: i,
      charAtStringStart: G[i].toString().indexOf(P[0].toString()),
      charAtStringEnd: (G[i].toString().indexOf(P[0].toString())) + P[0].toString().length - 1
    })
  }
}

所以我遍历G。首先，我检查P中是否还存在G[0]。如果是这样，我将其indexOf推到第一个字符和最后一个字符。所以我的输出是

[
    {
        line: 0,
        charAtStart: 0,
        charAtEnd: 2,
    }
]

问题是它确实只检测到第一次出现然后继续进行。我是否应该使用嵌套循环来获取所有出现的信息？

修改我不小心提供了错误的输出。我已经更改了。

Answer 1

基本上，您需要三个级别的嵌套循环：

遍历G中的值
为G中的每个值覆盖P中的值
遍历G值以查找所有出现的P值

第三部分可以通过indexOf上的commissionValue循环来完成，将while的值设置为刚好超过上一场比赛的开始：

fromIndex

Answer 2

您可以使用.indexOf()递归地执行此操作，并为每个新的递归传递起始索引。您将需要对图形中的每个“线”进行递归：

const G = [
  [9,9,9,9,9,9]
];

const P = [
  [9,9]
];

const findIndexOf = (line, lineArr, innerP, idx = 0) => {  
  const charAtStart = lineArr.toString().indexOf(innerP.toString(), idx);
  const charAtEnd = charAtStart + innerP.toString().length-1;
  if(charAtStart === -1)
    return [];
  
  return [{line, charAtStart, charAtEnd}, ...findIndexOf(line, lineArr, innerP, charAtEnd)];
}

const res = G.reduce((acc, line, i) => 
  [...acc, ...findIndexOf(i, line, P[i])], []);

console.log(res);

如果您希望为每行（而不只是G数组中与其关联的行）对模式进行批处理，则可以使用其他内部.reduce()方法，该方法将在每行上循环模式在您的图形中如下所示：

const G = [
  [9,9,9,9,9,9],
  [9,9,9,9,9,9]
];

const P = [
  [9,9]
];

const findIndexOf = (line, lineArr, innerP, idx = 0) => {  
  const charAtStart = lineArr.toString().indexOf(innerP.toString(), idx);
  const charAtEnd = charAtStart + innerP.toString().length-1;
  if(charAtStart === -1)
    return [];
  
  return [{line, charAtStart, charAtEnd}, ...findIndexOf(line, lineArr, innerP, charAtEnd)];
}

const res = G.reduce((acc, line, i) => 
  [...acc, ...P.reduce((r, p) => [...r, ...findIndexOf(i, line, p)], [])], []);

console.log(res);

Answer 3

您只需要通过G循环1次，因为您说P将是一个单行数组。

使用indexOf将G值与模式进行比较将为您提供模式出现的索引。

然后，您只需要更改您的indexOf调用即可开始最后一次出现模式的位置。第二个indexOf参数将解决这个问题。

此代码段应该起作用，忽略,个字符：

var G = [[9,9,9,9,9,9]];
var P = [[9,9]];

var pattern = P[0].join('');
var availableFirstLines = [];

for (let i = 0; i < G.length; i++) {
  var currentArray = G[i];
  var stringArray = currentArray.join('');
  let indexOccurrence = 0;

  while (indexOccurrence != -1) {
    // This will set the index to the the beginning of the pattern occurrence.
    indexOccurrence = stringArray.indexOf(pattern, indexOccurrence);

    if (indexOccurrence != -1) {
        availableFirstLines.push({
          line: i,
          charAtStart: indexOccurrence,
          charAtEnd: indexOccurrence + pattern.length
        });

        // This will make sure to ignore the previous encountered occurrence.
        indexOccurrence += pattern.length;
    }
  }
}

console.log(availableFirstLines);

每个数组都出现在二维数组中

3 个答案: