如何在JAVA中将数组元素合并到循环中？

如果一个数组在相邻位置包含相同的数字，它们将合并为一个数字，如下面的输入和输出示例所示，该值为该值的两倍

int[] test = {2,0,2,4,0,0,4};
Tile.alter(test)
true
test
{ 4, 8, 0, 0, 0, 0, 0 } //(the two 2’s merged, and the two 4’s merged)
int[] test = {2,0,4,2,0,0,4};
Tile.alter(test)
true
test
{ 2, 4, 2, 4, 0, 0, 0 } //(nothing merged – the 2’s are not adjacent, nor are the 4’s)

我试过这个，但它不起作用：

int curr=size[i];
if(size.length<=0)
int prev = size[0];
size[0]=size[0]*size[1];
for(int j = 0;j<size.length;j++)
size[j]=prev*size[j+1];
prev=curr;
size[size.length-1]=prev *size[size.length-1];

---

所以我真的不明白你想做什么，但我猜：

从数组开始

int[] a = {/*Some numbers*/};

然后将数组的值向左移动，直到得到块的和为止

for (int i = 0, index = 0, current = a[0]; i < a.length; i++) {
    if (a[i] == 0) {
        continue;
    } else if (current == 0) {
        current = a[i];
    }
    if (a[i] == current) {
        a[index] += current;
    } else {
        index++;
        current = a[i];
        a[index] = current;
    }
    if (i != index) {
        a[i] = 0;
    }
}

---

如果我所有的假设都是正确的，这可能会起作用，我还没有测试过。如果需要使用新阵列，则只需在开始之前克隆一个即可。

此问题可以通过多种方式解决，但对于清晰易懂的代码，我建议采用以下方法：

首先将中间零移到末尾，这样可以使非零元素彼此相邻。例如：

[2,0,2,4,0,0,4]=>[2,2,4,4,0,0,0]

两个接两个地进行可能的合并，因为您不需要链合并：

[2,2,4,4,0,0,0]=>[4,0,8,0,0,0,0]

再次将中间值0移到末尾：

[4,0,8,0,0,0,0]=>[4,8,0,0,0,0,0]

由于上面的每个阶段都可以使用一次对数组的迭代来完成，因此整个算法从现在开始

您可以找到如下算法实现：

import java.util.Arrays;

public class MergeAdjacent {
    
    private static int[] mergeLeft(int[] original) {
        int[] zeroShiftedForMerge = shiftZerosToRight(original);
        //
        for (int i = 0; i < zeroShiftedForMerge.length-1; i++) {
            if(zeroShiftedForMerge[i] == 0)
                break;
            if(zeroShiftedForMerge[i] == zeroShiftedForMerge[i+1]) {                
                zeroShiftedForMerge[i] += zeroShiftedForMerge[i+1];
                zeroShiftedForMerge[i+1] = 0;   
                i++;
            }           
        }
        //
        return shiftZerosToRight(zeroShiftedForMerge);
    }
    
    private static int[] shiftZerosToRight(int[] original) {
        int[] zeroShifted = new int[original.length];
        int ind = 0;
        for (int i = 0; i < original.length ; i++) {
            if(original[i] != 0) {
                zeroShifted[ind++] = original[i]; 
            }
        }
        return zeroShifted;
    }

    public static void main(String[] args) {
        int[] test1 = {2,0,2,4,0,0,4};
        int[] test2 = {2,0,4,2,0,0,4};
        int[] test3 = {2,0,0,2,0,0,4};
        int[] test4 = {2,0,4,2,0,0,2};
        int[] test5 = {4,0,4,4,2,0,4};
        //
        int[] merged1 = mergeLeft(test1);
        int[] merged2 = mergeLeft(test2);
        int[] merged3 = mergeLeft(test3);
        int[] merged4 = mergeLeft(test4);
        int[] merged5 = mergeLeft(test5);
        //
        System.out.println(Arrays.toString(test1) +" => "+ Arrays.toString(merged1));
        System.out.println(Arrays.toString(test2) +" => "+ Arrays.toString(merged2));
        System.out.println(Arrays.toString(test3) +" => "+ Arrays.toString(merged3));
        System.out.println(Arrays.toString(test4) +" => "+ Arrays.toString(merged4));
        System.out.println(Arrays.toString(test5) +" => "+ Arrays.toString(merged5));
    }
}

运行上述程序以查看输入和输出：

[2,0,2,4,0,0,4]=>[4,8,0,0,0,0,0]

[2,0,4,2,0,0,4]=>[2,4,2,4,0,0,0]

[2,0,0,2,0,0,4]=>[4,4,0,0,0,0,0]

[2,0,4,2,0,0,2]=>[2,4,4,0,0,0,0]

[4,0,4,4,2,0,4]=>[8,4,2,4,0,0,0]

---

希望这会有帮助。

下一个val循环1必须使用两个，compair循环1必须使用另一个。为什么需要排序为{4,8,0,0,0,0,0}的答案，以及为实现这一点所做的工作。他正在尝试做类似于1024或2048场游戏中发生的合并的事情。@therealboyi:在这种情况下，你期望得到什么：{2,0,4,2,0,0,2}？{2,8,0,0,0,0,0,0}或{2,4,4,0,0,0,0,0}？@statefi，我希望{2,4,4,0,0,0,0,0}好的，@Clone Talk的上述方法是有效的，但是输出数组中的第0位在与任何其他类似的原始数字合并之前一直将自身乘以2。不管怎么说，要修好它吗？