查找也是字符串后缀的最长前缀-Javascript

Question

Link to codewars challenge

I need to return the length of the longest prefix that is also a suffix of a string in Javascript.

As far as I understand, the prefixes in "abcd" are:

['a', 'ab', 'abc']

And the suffixes in "abcd" are:

[ 'bcd', 'cd', 'd' ]

So the length of the longest prefix that is also a suffix in "abcd" in this case is 0, because there are no prefixes that are also suffixes in "abcd" .

So far I've been able to figure out how to get the suffixes into an array for comparison, but not the prefixes.

function returnLongestPrefixAndSuffix(string) {

  let prefixes = [];
  let suffixes = [];

  for (let i = 0; i < string.length -1; i++) {
    prefixes.push(string.slice(i));
  }

  for (let i = 1; i < string.length; i++) {
    suffixes.push(string.slice(i));
  }

  return prefixes + " " + suffixes;

}

console.log(returnLongestPrefixAndSuffix("abcd"));

I'm not grasping the concept of how to start at the beginning of a string and add a larger element to the array each time by one character, excluding the element that would include the last one.

Please follow my current logic if possible.

EDIT : My code now looks like this:

function solve(string) {

    let prefixes = [];
    let suffixes = [];
    let includedList = [];

    for (let i = 1; i < string.length; i++) {
      prefixes.push(string.slice(0, i));
    }

    for (let i = 1; i < string.length; i++) {
      suffixes.push(string.slice(-i));
    }

    console.log(prefixes);
    console.log(suffixes);

    for (let i = 0; i < prefixes.length; i++) {
        let element = prefixes[i];
        if (suffixes.includes(element) === true) {
            includedList.push(element);
        }
    }

    console.log(includedList);
    if (includedList.length === 0) {
        return 0;
    }
    else {
        let overlap = prefixes.filter(value => suffixes.includes(value));
        console.log(overlap);
        let longest = includedList.sort(function (a, b) { return b.length - a.length; })[0];
        return longest.length;
    }
}

console.log(solve("abcdabc"));

And this is passing 10049 test but failing 163 tests on codewars. I still do not know what to do with the overlap variable or how to exclude overlaps from the includedList array.

Answer 1

function solve(string) {

    for (let i = Math.floor(string.length / 2); i > 0; i--) {

        let prefix = string.slice(0, i);
        let suffix = string.slice(-i);

        if (prefix == suffix) {
            return i;
        }
    }
    return 0;
}

console.log(solve("abcdabc"));

To account for the overlap, initialize your for-loop like this:

let i = Math.floor(string.length / 2)

That will initialize the for-loop at the half-way point in your string, so that you can count down and compare whether or not the prefix == the suffix, starting with the longest.

You could return prefix.length , but that will be the same thing as i .

Also, be sure to return 0 outside of the for-loop. Because if you try:

if (prefix != suffix) {
    return 0;
   }

inside of the for-loop, it will stop counting right there.

Answer 2

To get the prefixes, you can use the second argument of .slice :

  string.slice(0, i)

Note that to get the suffixes, you could also take the string from the end:

  string.slice(-i)

There is no sense in collecting prefixes and suffixes in arrays, just search for the biggest i where the suffix equals the prefix.

Answer 3

Please see the documentation of the slice function, it may take a second argument: https://www.w3schools.com/jsref/jsref_slice_string.asp

So following your logic, one way to get prefixes would be to:

for (let i = 1; i <= string.length; i++) {
  prefixes.push(string.slice(0, i));
}

EDIT: Your newest code doesn't work because of two reasons:

1. You may end up with includedList being empty, but you still try to get first element out of it.

2. You don't take overlaps into consideration. For the input aaa the correct result is a since prefix aa overlaps with the corresponding suffix. In other words the result can't be longer than half the length of the input.