将数组中连续的相同项混在一起，使输出数组没有连续的值。Javascript

它的想法是，在数组中基本上没有重复的值，这些值具有相似的值

示例数组包含值

input = [1,2,2,2,2,3,4,5,6,7,8,9]<br/>

input=[1,2,2,2,3,4,5,6,7,8,9]

预期输出将具有某些内容

likeoutput = [1,2,3,2,4,2,5,2,6,2,7,8,9]<br/>

likeoutput=[1,2,3,2,4,2,5,2,6,2,7,8,9]

---

我试着把它放在一个for循环中，在那里它检查下一个项目，如果它是相同的，则交换值。问题是当我有连续的相似值时。

也许这可以帮助您：

for(var i = 1; i < input.length; i++) {
    if(input[i-1] == input[i]) {
        var j = i;
        while(j < input.length && input[j] == input[i]) {
            j++;
        }
        var el = input[j];
        input[j] = input[i];
        input[i] = el;  
    }
}

for（变量i=1；i

也许这可以帮助您：

for(var i = 1; i < input.length; i++) {
    if(input[i-1] == input[i]) {
        var j = i;
        while(j < input.length && input[j] == input[i]) {
            j++;
        }
        var el = input[j];
        input[j] = input[i];
        input[i] = el;  
    }
}

for（变量i=1；i

此提案的特点

• 对元素进行计数并将其存储在适当的对象中
• 检查是否可能分散（例如，此处不存在

  [1,1,1,1,3,3]

  ）
• 元素循环，所以
• 相同元素之间的最大距离

它是如何工作的

我以这个数组为例：

[1,2,2,2,3,4,5,6,7,8,9]

使用元素的计数构建一个对象，并将其作为键存储

length = {
      "1": 1, "2": 4, "3": 1, "4": 1, "5": 1, "6": 1, "7": 1, "8": 1, "9": 1
  }

选择具有最大值的属性：

length[2]=4

使用上一个值的长度创建一个新数组，并用空数组填充它

output = [[], [], [], [], []]

检查是否可以使用扩展阵列。如果没有，请返回

将

k

设置为属性最大值的键

k = '2'

如果是真的，继续。否则，请转到11

将

l

设置为

length[k]

的值

l = 4

迭代

l

并将

k

按到数组末尾，索引为

i%outputLength

。增加

i

删除属性

k

继续进行第5步

返回平面

输出
数组

output   first  then continued
array 0:     2     1     6
array 1:     2     3     7
array 2:     2     4     8
array 3:     2     5     9

return:      2  1  6  2  3  7  2  4  8  2  5  9
distance     |        |        |        |       is equal  

功能扩展（输入）{
函数findMaxKey（）{
var max=0，键；
Object.keys（长度）.forEach（函数（k）{
如果（长度[k]>最大值）{
最大值=长度[k]；
key=k；
}
});
返回键；
}
变量长度=输入.reduce（函数（r，a）{
r[a]=（r[a]| 0）+1；
返回r；
}, {}),
i=0，k=findMaxKey（），l，
outputLength=长度[k]，
output=Array.apply（数组，{length:outputLength}）.map（函数（）{return[]；}）；
if（input.length-outputLength
.as控制台包装{max height:100%！important；top:0；}
此方案的特点


对元素进行计数并将其存储在适当的对象中
检查是否可能分散（例如，此处不存在
[1,1,1,1,3,3]
）
元素循环，所以
相同元素之间的最大距离

它是如何工作的

我以这个数组为例：
[1,2,2,2,3,4,5,6,7,8,9]

使用元素的计数构建一个对象，并将其作为键存储

length = {
      "1": 1, "2": 4, "3": 1, "4": 1, "5": 1, "6": 1, "7": 1, "8": 1, "9": 1
  }


选择具有最大值的属性：
length[2]=4
使用上一个值的长度创建一个新数组，并用空数组填充它

output = [[], [], [], [], []]


检查是否可以使用扩展阵列。如果没有，请返回
将
k
设置为属性最大值的键

k = '2'


如果是真的，继续。否则，请转到11
将
l
设置为
length[k]
的值

l = 4


迭代
l
并将
k
按到数组末尾，索引为
i%outputLength
。增加
i
删除属性
k
继续进行第5步
返回平面
输出
数组

output   first  then continued
array 0:     2     1     6
array 1:     2     3     7
array 2:     2     4     8
array 3:     2     5     9

return:      2  1  6  2  3  7  2  4  8  2  5  9
distance     |        |        |        |       is equal  



功能扩展（输入）{
函数findMaxKey（）{
var max=0，键；
Object.keys（长度）.forEach（函数（k）{
如果（长度[k]>最大值）{
最大值=长度[k]；
key=k；
}
});
返回键；
}
变量长度=输入.reduce（函数（r，a）{
r[a]=（r[a]| 0）+1；
返回r；
}, {}),
i=0，k=findMaxKey（），l，
outputLength=长度[k]，
output=Array.apply（数组，{length:outputLength}）.map（函数（）{return[]；}）；
if（input.length-outputLength