Question

我有2个数组。

1: [a, ab, abc, abcde]
2: [a, ab, abc, abcde, abcdefe, axde]

在第一个数组中，我使用此代码来获得最长的行。

function longestChain(words) {
    // Write your code here
    var xintTOstring = "";
    var result = 0;
    for (var x = 0; x < words.length; x++){
        xintTOstring = words[x].toString();

            if (xintTOstring.length > result) {
                result = xintTOstring.length;
            }

    }
    return result;
}

，但是在第二个数组中，最长的是“ axde”。因为该数组中的abcde不能最长，因为它的值相等。

我尝试了此代码，但没有得到预期的结果。并且最长的行是abcdefer。

问题：如何获取最长的线并检查其值是否与字符串中的值相等。我尝试了这段代码，但没有得到正确的输出。

function longestChain(words) {
    // Write your code here
    var xintTOstring = "";
    var result = 0;
    for (var x = 0; x < words.length; x++){
        xintTOstring = words[x].toString();
        if (!words[x].toString().inclcudes(xintTOstring)) {
            if (xintTOstring.length > result) {
                result = xintTOstring.length;
            }
        }
    }
    return result;
}

致谢

Answer 1

function equalLike(word) {
     // should the equality be checked within the array or in global stream?
}

function longestChain(words) {
    return words.reduce((longest,word) => longest = longest.length > equalLike(word).length ? 
                                                    longest : word,'');
}

最长的单词充当累加器。

Answer 2

如果我理解正确，则每次调用最长的单词应返回未找到的最长的单词。浏览每个列表，保留最长单词的对象，对照该对象，然后对照键检查子字符串

const longestWords = {};

const longestChain = function(words) {
  let longestInList = "";

  words.forEach(function(word) {
    if (validLongestWord(word) && word.length > longestInList.length) {
      longestInList = word;
    }
  });

  longestWords[longestInList] = longestInList.length; //maybe handy for sorting later

  return longestInList;
}

const validLongestWord = function(word) {
    if(longestWords[word]) return false;

  return !Object.keys(longestWords).some(key=>key.indexOf(word) >=0);
}

console.log(longestChain(["a", "ab", "abc", "abcde", "abcdefe", "axde"])); //abcdefe
console.log(longestChain(["a", "ab", "abc", "abcde", "abcdefe", "axde"])); //axde
console.log(longestChain(["a", "ab", "abc", "abcde", "abcdefe", "axde"])); //none

Answer 3

我相信这是OP试图使用JavaScript解决的问题：

Longest Character Removal Chain 和 Interview Questions - String Chain

任何人都欢迎编辑此答案以为所提出的问题提供解决方案。

var StackOverFlow;
(function(StackOverFlow) {
  var LongestChain = (function() {
    function LongestChain() {}
    LongestChain.main = function(args) {
      // Array of words
      var words = ["a", "ab", "abc", "abcdefe", "axde"];
      console.info(
        "Longest Chain Length : " + LongestChain.longest_chain(words)
      );
    };
    LongestChain.longest_chain = function(w) {
      if (null == w || w.length < 1) {
        return 0;
      }
      var maxChainLen = 0;
      var words = w.slice(0).slice(0);
      var wordToLongestChain = {};
      for (var index7809 = 0; index7809 < w.length; index7809++) {
        var word = w[index7809];
        {
          if (maxChainLen > word.length) {
            continue;
          }
          var curChainLen =
            LongestChain.find_chain_len(word, words, wordToLongestChain) + 1;
          /* put */ wordToLongestChain[word] = curChainLen;
          maxChainLen = Math.max(maxChainLen, curChainLen);
        }
      }
      return maxChainLen;
    };
    LongestChain.find_chain_len = function(word, words, wordToLongestChain) {
      var curChainLen = 0;
      for (var i = 0; i < word.length; i++) {
        var nextWord = word.substring(0, i) + word.substring(i + 1);
        if (words.indexOf(nextWord) >= 0) {
          if (wordToLongestChain.hasOwnProperty(nextWord)) {
            curChainLen = Math.max(
              curChainLen,
              /* get */ (function(m, k) {
                return m[k] ? m[k] : null;
              })(wordToLongestChain, nextWord)
            );
          } else {
            var nextWordChainLen = LongestChain.find_chain_len(
              nextWord,
              words,
              wordToLongestChain
            );
            curChainLen = Math.max(curChainLen, nextWordChainLen + 1);
          }
        }
      }
      return curChainLen;
    };
    return LongestChain;
  })();
  StackOverFlow.LongestChain = LongestChain;
  LongestChain["__class"] = "StackOverFlow.LongestChain";
})(StackOverFlow || (StackOverFlow = {}));
StackOverFlow.LongestChain.main(null);

如何在没有相似值的情况下获得数组中最长的字符串？

3 个答案: