Javascript 两个数组中的最长数列

我有两个数组，它们以0-9之间的随机数初始化
我需要找到它们中存在的最长的相同序列

比如说

var arrFirst = [8,5,3,0,3,1,8,2,8,7,3,5,4,0,8,5,7,3,1]
var arrSecond = [8,5,4,0,2,9,4,3,6,9,2,3,1,8,2,8,7,3,3]

结果数组需要包含两个数组中出现的最长序列

var arrResult = [3,1,8,2,8,7,3]

在本例中，我们在开始[8,5]处有序列，但它不是最长的序列

你能提供一些代码来帮助我吗

Thanx

伪代码：

1)create two more arrays for longest sequence and another one for running sequence
2)Start looking for matches between 2 original arrays
3)Keep current sequence in runningSequence array
4)check if arrays match
  5)if so check if length of running sequence is longer than theLongestSequence array
    6)If so, replace the longestSequenceArray content with runningSequence array and keep going
    7)if not, proceed to next char position
8)Repeat until all chars in original arrays are processed by going back to step 4
9)Print Longest array content

您有责任为上述逻辑编写代码

祝你好运。

伪代码：

1)create two more arrays for longest sequence and another one for running sequence
2)Start looking for matches between 2 original arrays
3)Keep current sequence in runningSequence array
4)check if arrays match
  5)if so check if length of running sequence is longer than theLongestSequence array
    6)If so, replace the longestSequenceArray content with runningSequence array and keep going
    7)if not, proceed to next char position
8)Repeat until all chars in original arrays are processed by going back to step 4
9)Print Longest array content

您有责任为上述逻辑编写代码

---

祝你好运。

像这样搜索第二个数组中存在的最大长度

var arrFirst=[8,5,3,0,3,1,8,2,8,7,3,5,4,0,8,5,7,3,1]；
var arrSecond=[8,5,4,0,2,9,4,3,6,9,2,3,1,8,2,8,7,3,3]；
var firstStr=arrFirst.join（“”）；
var secondStr=arrSecond.join（“”）；
var组合=getCombination（firstStr）；
组合=组合。排序（函数（a，b）{
返回b.length-a.length；
});
对于（组合中的var i）{
if（secondStr.indexOf（组合[i]）！=-1）{
console.log（找到的组合[i]+，长度为：“+组合[i].length”）；
console.log（组合[i].split（“”）；
打破
}
}
函数getcomposition（str）{
var fn=功能（活动、静止、a）{
如果（！active&&！rest）
返回；
如果（！rest）{
如果（第一个str.search（活动）！=-1）{
a、 推送（主动）；
}
}否则{
fn（主动+静止[0]，静止切片（1），a）；
fn（主动，静止切片（1），a）；
}
返回a；
}
返回fn（“，str，[]）；
}

像这样搜索第二个数组中存在的最大长度

var arrFirst=[8,5,3,0,3,1,8,2,8,7,3,5,4,0,8,5,7,3,1]；
var arrSecond=[8,5,4,0,2,9,4,3,6,9,2,3,1,8,2,8,7,3,3]；
var firstStr=arrFirst.join（“”）；
var secondStr=arrSecond.join（“”）；
var组合=getCombination（firstStr）；
组合=组合。排序（函数（a，b）{
返回b.length-a.length；
});
对于（组合中的var i）{
if（secondStr.indexOf（组合[i]）！=-1）{
console.log（找到的组合[i]+，长度为：“+组合[i].length”）；
console.log（组合[i].split（“”）；
打破
}
}
函数getcomposition（str）{
var fn=功能（活动、静止、a）{
如果（！active&&！rest）
返回；
如果（！rest）{
如果（第一个str.search（活动）！=-1）{
a、 推送（主动）；
}
}否则{
fn（主动+静止[0]，静止切片（1），a）；
fn（主动，静止切片（1），a）；
}
返回a；
}
返回fn（“，str，[]）；
}

您可以用

array2

的每个元素检查

array1

的ech元素，然后用

检查元素，同时用计数器循环，并为每个数组设置索引的偏移量

稍后检查找到的相同元素的长度是否大于或等于上次找到的数组，并用新的较长数组替换结果集，或者追加（如果等于结果集）


var array1=[8,5,3,0,3,1,8,2,8,7,3,5,4,0,8,5,7,3,1]，
array2=[1,8,4,0,2,9,4,3,6,9,2,3,1,8,2,8,7,3,3]，
结果=阵列1.reduce（函数（r，u，i，a）{
数组2.forEach（函数{
var k=0，
温度=[]；
而（（i+k）在a&&（j+k）在b&&a[i+k]==b[j+k]）{
温度推送（a[i+k]）；
k++；
}
如果（！r.length | | temp.length>r[0].length）{
r=[temp]；
返回；
}
if（temp.length==r[0].length）{
r、 推动（温度）；
}
});
返回r；
}, []);
控制台日志（结果）
作为控制台包装{max height:100%！important；top:0；}
您可以用
array1
的每个元素检查
array2
的ech元素，然后用
检查元素，同时用计数器循环
并为每个数组检查索引的偏移量

稍后检查找到的相同元素的长度是否大于或等于上次找到的数组，并用新的较长数组替换结果集，或者追加（如果等于结果集）


var array1=[8,5,3,0,3,1,8,2,8,7,3,5,4,0,8,5,7,3,1]，
array2=[1,8,4,0,2,9,4,3,6,9,2,3,1,8,2,8,7,3,3]，
结果=阵列1.reduce（函数（r，u，i，a）{
数组2.forEach（函数{
var k=0，
温度=[]；
而（（i+k）在a&&（j+k）在b&&a[i+k]==b[j+k]）{
温度推送（a[i+k]）；
k++；
}
如果（！r.length | | temp.length>r[0].length）{
r=[temp]；
返回；
}
if（temp.length==r[0].length）{
r、 推动（温度）；
}
});
返回r；
}, []);
控制台日志（结果）
<代码>作为控制台包装器{max身高：100%！重要；顶部：0；} /COD> > p>我发布了这个任务的C++解决方案，以防有人需要。
void clear(int *ar, int n)
{
    for (int i = 0; i < n; i++)
    {
        ar[i] = 0;
    }
}

void copy(int*first, int *second, int n)
{
    for (int i = 0; i < n; i++)
    {
        first[i] = second[i];
    }
}

int main() {

    int ar_1[] = { 8,5,3,0,3,1,8,2,8,7,3,5,4,0,8,5,7,3,1 };
    int ar_2[] = { 8,5,4,0,2,9,4,3,6,9,2,3,1,8,2,8,7,3,3 };

    const int arr_size = sizeof(ar_1) / sizeof(int);

    int arr_longest[arr_size] = { 0 };
    int sequence_counter = 0;

    int arr_temp[arr_size] = { 0 };
    int temp_counter = 0;

    for (int i = 0; i < arr_size; i++)
    {
        bool match = false;
        int inner_counter = 0;

        for (int k = 0; k < arr_size; k++)
        {
            if (match)
            {
                if (ar_1[++inner_counter] == ar_2[k])
                {
                    arr_temp[temp_counter++] = ar_2[k];
                }
                else
                {
                    if (temp_counter > sequence_counter)
                    {
                        sequence_counter = temp_counter;
                        copy(arr_longest, arr_temp, arr_size);
                    }

                    clear(arr_temp, arr_size);
                    temp_counter = 0;
                    match = false;
                }
            }
            else if (ar_1[i] == ar_2[k])
            {
                arr_temp[temp_counter++] = ar_1[i];
                inner_counter = i;
                match = true;
            }
        }
    }
}

void clear（int*ar，int n）
{
对于（int i=0；i