Javascript 中最长的公共前缀

Question

我正在尝试解决 Leet Code 挑战14. Longest Common Prefix：

编写一个函数来查找字符串数组中最长的公共前缀字符串。

如果没有公共前缀，则返回空字符串""。

示例 1：

Input: strs = ["flower","flow","flight"]
Output: "fl"

示例 2：

Input: strs = ["dog","racecar","car"]
Output: ""

说明：输入字符串之间没有共同的前缀。

约束：

• 1 <= strs.length <= 200
• 0 <= strs[i].length <= 200
• strs[i] 仅由小写英文字母组成。

我的解决方案：

let strs = ["flower", "flow", "flight"];

var longestCommonPrefix = function (strs) {
  for (let i = 0; i < strs.length; i++) {
    for (let j = 0; j < strs[i].length; j++) {
       // console.log(strs[i+2][j]);
      if (strs[i][j] == strs[i + 1][j] && strs[i + 1][j] ==strs[i + 2][j]) {
        return (strs[i][j]);
        
      } else {
        return "0";
      }
    }
  }
};

console.log(longestCommonPrefix(strs));

输出：f

如何遍历每个字符并检查它是否相同然后继续下一步，如果失败则返回最长的公共前缀？

Answer 1

由于最长的公共前缀必须出现在数组的每个字符串中，您可以迭代长度并检查所有单词在该索引处是否具有相同的字符，直到找到差异

function prefix(words){
  // check border cases size 1 array and empty first word)
  if (!words[0] || words.length ==  1) return words[0] || "";
  let i = 0;
  // while all words have the same character at position i, increment i
  while(words[0][i] && words.every(w => w[i] === words[0][i]))
    i++;
  
  // prefix is the substring from the beginning to the last successfully checked i
  return words[0].substr(0, i);
}

console.log(1, prefix([]));
console.log(2, prefix([""]));
console.log(3, prefix(["abc"]));
console.log(4, prefix(["abcdefgh", "abcde", "abe"]));
console.log(5, prefix(["abc", "abc", "abc"]));
console.log(6, prefix(["abc", "abcde", "xyz"]));

Answer 2

一些问题：

• 您的内部循环将在其第一次迭代中遇到return。这意味着您的循环将永远不会重复，并且返回值将始终是一个字符。

• 在循环中寻址 strs[i+1] 和 strs[i+2] 是错误的，因为这些索引会超出范围 (>= strs.length)

您可以使用子字符串（前缀）比较（在一个操作中），而不是逐个字符地进行比较：这可能看起来很浪费，但是由于这种比较发生在 JavaScript 代码“下方”，它非常快（并且作为字符串大小限制为 200 个字符，这很好）。

该算法可以从选择一个现有字符串作为前缀开始，然后每次输入中有一个没有它作为前缀的字符串时缩短它。最后，您将留下通用前缀。

最好以 shortest 字符串作为初始前缀候选，因为公共前缀肯定不能比这更长。

var longestCommonPrefix = function(strs) {
    let prefix = strs.reduce((acc, str) => str.length < acc.length ? str : acc);
    
    for (let str of strs) {
        while (str.slice(0, prefix.length) != prefix) {
            prefix = prefix.slice(0, -1);
        }
    }
    return prefix;
};

let res = longestCommonPrefix(["flower","flow","flight"]);

console.log(res);

Answer 3

不是最好的解决方案，但这应该可行

function longestPrefix(strs){
    if(strs.length <1){
        return "";
    }
    const sharedPrefix=function(str1,str2){
        let i=0;
        for(;i<Math.min(str1.length,str2.length) /*todo optimize*/;++i){
            if(str1[i] !== str2[i]){
                break;
            }
        }
        return str1.substr(0,i);
    };
    let curr = strs[0];
    for(let i=1;i<strs.length;++i){
        curr=sharedPrefix(curr,strs[i]);
        if(curr.length < 1){
            // no shared prefix
            return "";
        }
    }
    return curr;
}

Answer 4

一种基于字长排序的方法，对于最短的单词，为了提前退出，完全基于Array.every的前缀验证和聚合...

function longestCommonPrefix(arr) {
  const charList = [];

  const [shortestWord, ...wordList] =
    // sort shallow copy by item `length` first.
    [...arr].sort((a, b) => a.length - b.length);

  shortestWord
    .split('')
    .every((char, idx) => {
      const isValidChar = wordList.every(word =>
        word.charAt(idx) === char
      );
      if (isValidChar) {
        charList.push(char);
      }
      return isValidChar;
    });

  return charList.join('');
}

console.log(
  longestCommonPrefix(["flower","flow","flight"])
);

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

Answer 5

这个：

strs[i][j] == strs[i + 1][j] ==strs[i + 2][j]

在 JS 中没有意义......或者至少，你正在做的事情没有意义......要做到这一点，你应该使用 && 运算符，如下所示：

strs[i][j] == strs[i + 1][j] && strs[i + 1][j] ==strs[i + 2][j]

否则 JS 将评估第一个条件，然后将评估该操作的结果（true 或 false）与第三个值

除此之外，考虑到您在数组上循环使用i，因此i 也将是str.length - 1，但在您引用strs[i + 2][j] 的情况下，在这种情况下将是@987654330 @在你的情况下，没有意义。

关于解决方案：
您应该考虑前缀对于数组中的所有值都是通用的，因此您可以考虑一个值，然后检查所有其他值是否相等......最明显的是第一个，您最终会像这样：

let strs = ["flower", "flow", "flight", "dix"];

function longestCommonPrefix (strs) {
  // loop over the characters of the first element
  for (let j = 0; j < strs[0].length; j++) {
    // ignore the first elements since is obvious that is equal to itself
    for (let i = 1; i < strs.length; i++) {
       /* in case you have like 
        [
          'banana',
          'bana'
        ]
        the longest prefix is the second element
       */
       if(j >= strs[i].length){
         return strs[i]
       }
       // different i-th element
       if(strs[0][j] != strs[i][j]){
         return strs[0].substr(0, j)
       }
       
    }
  }
  // all good, then the first element is common to all the other elements
  return strs[0]
};

console.log(longestCommonPrefix(strs));

Answer 6

let strs = ["flower", "flow", "flight"];

var longestCommonPrefix = function (strs) {
  for (let i = 0; i < strs.length; i++) {
    for (let j = 0; j < strs[i].length; j++) {
        console.log(strs[i+2][j]);
      if (strs[i][j] == strs[i + 1][j] && strs[i][j]  ==strs[i + 2][j]) {
        return (strs[i][j]);
        


      } else {
        return "0";
      }
    }
  }
};

console.log(longestCommonPrefix(strs));

这个**返回** f

Answer 7

当列表中所有单词的索引处的字母相同时，增加索引。然后切片。

function prefix(words) {
  if (words.length === 0) { return '' }
  let index = 0;
  while (allSameAtIndex(words, index)) {
    index++;
  }
  return words[0].slice(0, index);
}

function allSameAtIndex(words, index) {
  let last;
  for (const word of words) {
    if (last !== undefined && word[index] !== last[index]) {
      return false;
    }
    last = word;
  }
  return true;
}

Answer 8

我假设你是来解决 Leetcode 问题的。

var longestCommonPrefix = function(strs) {
let arr = strs.concat().sort();
const a1 = arr[0];
const a2 = arr[arr.length -1];
const length = a1.length;
let i=0;

while(i<length && a1.charAt(i) == a2.charAt(i)) i++;
return a1.substring(0,i);

};

Answer 9

function prefixLen(s1, s2) {
    let i = 0;
    while (i <= s1.length && s1[i] === s2[i]) i++;
    return i;
}

function commonPrefix(arr) {
    let k = prefixLen(arr[0], arr[1]);
    for (let i = 2; i < arr.length; i++) {
        k = Math.min(k, prefixLen(arr[0], arr[i]));
    }
    return arr[0].slice(0, k);
}

console.log(commonPrefix(['pirate', 'pizza', 'pilates']))  // -> "pi"

Answer 10

var longestCommonPrefix = function(strs) {
    let prefix = "";
    for(let i = 0; i < strs[0].length; i++) {
        for(let j = 1; j < strs.length; j++) {
            if(strs[j][i] !== strs[0][i]) return prefix;
        }
        prefix = prefix + strs[0][i];
    }
    return prefix;
};
console.log(longestCommonPrefix);