第一次出现的最长的、不重叠的重复子串是什么？答案

【问题标题】：What is the longest, non-overlapping repeating sub-string, first-occurring?第一次出现的最长的、不重叠的重复子串是什么？
【发布时间】：2018-02-05 20:51:02
【问题描述】：

我需要一个 JavaScript 答案，发现了一个 C++ solution 并转换了它。希望其他人会发现这很有用。

【问题讨论】：

您有问题吗？
认真的吗？你们在downvote触发手指上有点太快了，但成为我的客人......
嗯...看起来用户打开问题是为了后代发布自己的答案-不确定这是否是使用该网站的例外方式...
为什么不呢？我搜索了我需要的答案，但找不到。我没有向其他人索取，而是根据另一个论坛提出了自己的解决方案，并在此处发布以造福他人。
在Meta 中快速搜索后，它似乎是perfectly fine to answer your own question，即使在Q&A style you used 中也是如此。我的建议是，下次您想以这种方式发布和回答问题时，请在问题中记下不要投反对票，因为您即将发布自己的答案。然后在发布答案后在编辑中删除该注释。

标签： javascript

【解决方案1】：

从GeeksForGeeks转换过来的：

function longestRepeatedSubstring( str ) {
    "use strict";

    var n = str.length
        , LCSRe = createArray( n + 1, n + 1 )
        , res = ''
        , res_length = 0
        , index = 0
    ;

    // Setting all to 0
    for( var i = 0; i < n + 1; i++ ) {
         LCSRe[ i ].fill( 0 );
    }

    // building table in bottom-up manner
    for( var i = 1; i <= n; i++ ) {
        for( var j = i + 1; j <= n; j++ ) {

            // (j-i) > LCSRe[i-1][j-1] to remove
            // overlapping
            if(
                str[ i - 1 ] === str[ j - 1 ]
                &&
                LCSRe[ i - 1 ][ j - 1 ] < ( j - i ) 
            ){
                LCSRe[ i ][ j ] = LCSRe[ i - 1 ][ j - 1 ] + 1;

                // updating maximum length of the
                // substring and updating the finishing
                // index of the suffix
                if( LCSRe[ i ][ j ] > res_length ) {
                    res_length = LCSRe[ i ][ j ];
                    index = Math.max( i, index );
                }

            } else {
                LCSRe[ i ][ j ] = 0;
            }
        }
    }

    // If we have non-empty result, then insert all
    // characters from first character to last
    // character of string
    if( res_length > 0 ) {
        for( var i = index - res_length + 1; i <= index; i++ ) {
            res = res.concat( str[ i - 1 ] );
        }
    }

    return res;
}



function createArray( length ) {
    var arr = new Array( length || 0 )
        , i = length
    ;

    if( arguments.length > 1 ) {
        var args = Array.prototype.slice.call( arguments, 1 );
        while( i-- ) {
            arr[ length - 1 - i ] = createArray.apply( this, args );
        }
    }

    return arr;
}

命名函数完成这项工作（由Matthew Crumley's createArray 辅助函数支持），但我当然欢迎优化建议。注意：由于这是从 C++ 转换而来的，所以我保留了原始变量名称以及大多数原始编码器的 cmets。

一些测试：

longestRepeatedSubstring( "SOgeeksforgeeks" );
> geeks

longestRepeatedSubstring( "aab" );
> a

longestRepeatedSubstring( "aabaabaaba" );
> aaba

longestRepeatedSubstring( "aaaaaaaaaaa" );
> aaaaa

longestRepeatedSubstring( "banana" );
> an

需要明确的是，我在发布之前错过了Ben Doom's 的贡献。他使用正则表达式做同样的事情（使用循环）。在检查“香蕉”时，正则表达式解决方案轻松胜过循环解决方案，但loops run significantly faster 针对一大块随机数据。我不会假设知道每个人的用例，所以为了速度，我会在这里留下我的答案。

【讨论】：

太棒了。干得好