找到两个数组的最长公共后缀的最佳方法

Question

给定两个数组，我需要找到最长的公共后缀。

更准确地说，我需要在每个数组中找到索引，然后出现该后缀。

例如：

// Input
arr1 = [1,2,3,4,5,6];
arr2 = [11,12,13,5,6];

// Output
ind1 = 4;
ind2 = 3;

这是我的代码：

let ind1 = arr1.length - 1;
let ind2 = arr2.length - 1;
while (ind1 >= 0 && ind2 >= 0 && arr1[ind1] == arr2[ind2]) {
    ind1--;
    ind2--;
}
ind1++;
ind2++;

我可以在这里应用一个单语句技巧（或一般的“更清洁”方式）吗？

Answer 1

这绝对不是单语句技巧或更简洁的方法，但它本质上比你现有的代码做得更多。

根据讨论：

如果数组是这样的：[1,2,3,4,5,6,7,8,9]，[1,2,6,5,4,7,8,9]？ – 拉杰什

@Rajesh：试试代码。它应该给你 ind1 = 0 和 ind2 = 0。- goodvibration

@goodvibration 我需要找到最长的公共后缀，所以最长的后缀是 7,8,9 而不是 1,2 - Rajesh

哦，对不起，我认为它们在您的示例中是相同的。是的，这里的后缀是7,8,9，所以输出应该是ind1 = 6 and ind2 = 5。 --goodvibration

您正在寻找一个返回最大序列起始索引的逻辑。为此，您必须在返回索引之前捕获所有序列并检查它们的长度。

你可以试试下面的逻辑：

• 创建一个临时对象来保持位置。
• 现在循环数组。
  • 如果 Array1 的起始位置未定义，则查找匹配元素的索引。
  • 将此索引保存在临时对象中并继续。
  • 如果定义了 startPosition，则查找两个数组中的下一个值是否相等。
  • 如果相等，继续。
  • 如果没有，请创建一个组并从此索引重新开始该过程。

function getLongestSuffixIndex(a1, a2) {
  var temp = {}
  var groups = [];
  var lastA2Index = 0;
  var a2Index = -1;
  var part;

  function addGroup() {
    if (temp.startA1Index !== undefined) {
      groups.push({
        a1Index: temp.startA1Index,
        a2Index: temp.startA2Index,
        count: temp.endA1Index - temp.startA1Index + 1
      });
      temp = {};
    }
  }

  function checkForIndex(i) {
    a2Index = part.indexOf(a1[i]);
    if (a2Index >= 0) {
      temp.startA1Index = i;
      temp.startA2Index = a2Index + lastA2Index;
      lastA2Index += a2Index;
    }
  }

  for (var i = 0, len = a1.length; i < len; i++) {
    part = a2.slice(lastA2Index);
    if (temp.startA1Index === undefined) {
      checkForIndex(i);
    } else {
      var index = (temp.startA2Index || 0) + (temp.count|| 0) + 1
      if (a1[i] === a2[index]) {
        temp.endA1Index = i;
        temp.count = i - temp.startA1Index;
      } else {
        addGroup();
        checkForIndex(i);
      }
    }
  }
  addGroup();

  return groups.length ? groups.reduce(function(p, c) {
    return ((p.count || 0) > (c.count || 0)) ? p : c
  }) : undefined;
}

var arr1 = [1, 2, 3, 4, 5, 6];
var arr2 = [11, 12, 13, 5, 6];

console.log(getLongestSuffixIndex(arr1, arr2))
console.log(getLongestSuffixIndex([1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 6, 5, 4, 7, 8, 9]))

Answer 2

您可以使用单个变量从数组末尾向上计数。

var array1 = [1, 2, 3, 4, 5, 6],
    array2 = [11, 12, 13, 5, 6],
    l1 = array1.length - 1,
    l2 = array2.length - 1,
    i = 0;
    
while (i <= l1 && i <= l2 && array1[l1 - i] === array2[l2 - i]) {
    i++;
}

console.log('index array1', l1 - i + 1);
console.log('index array2', l2 - i + 1);

Answer 3

~ind1可以代替ind1 >= 0作为ind1 != -1的缩写：

while (~ind1 && ~ind2 && arr1[ind1] == arr2[ind2]) { ind1--; ind2--; }

可以移动减量以避免.length - 1（两个减量都需要&）：

var i = arr1.length, j = arr2.length; while (~--i & ~--j && arr1[i] == arr2[j]) { }

对于数值，条件可以更短，因为undefined - undefined 是NaN：

while (arr1[--i] - arr2[--j] == 0) { } 

---

我把每一个都放在一行与原来的比较，很抱歉混乱..

for ([a, b] of [ [[1,2,3,4], [1,'3',4]], [[1], [0,1]], [[], []], [[,], [0]] ]) 
{
  var i = a.length - 1; var j = b.length - 1; while (i >= 0 && j >= 0 && a[i] == b[j]) { i--; j--; } i++; j++; console.log(i, j, a.length - i)   /* original version */

  var i = a.length, j = b.length; while (~--i & ~--j && a[i] == b[j]) { } i++; j++; console.log(i, j, a.length - i)   /* ~--i is short for (i = i - 1) != -1 */

  var i = a.length, j = b.length; while (a[--i] - b[--j] == 0) { } i++; j++; console.log(i, j, a.length - i)   /* a bit shorter, but minus works only with values convertible to Number */
}

作为旁注，我希望一个通用的后缀函数返回一个字符串或字符数。