Java 比较数组中的连续元素并求和相同的值

输出：

66

说明：

12+12+12+15+15

---

是否有更好/更干净的方法来比较数组中的值，并仅在它们相等时添加值，而不使用实用程序方法？

您可以保留重复项的运行计数，并在运行结束时将它们添加到总和中

public class LoopTest {

    public static void main(String[] args) {

        int[] myarr = {12, 12, 12, 8, 15, 15};

        //Boolean array to mark the elements,defaults false 
        boolean[] b = new boolean[myarr.length];

        //Compare Consecutive values and mark them true if equal
        for (int i = 1; i < myarr.length; i++) {
            if (myarr[i - 1] == myarr[i]) {
                b[i - 1] = b[i] = true;
            }
        }
        int sum = 0;

        //Add all the values in myarr with indices marked as equal
        for (int i = 0; i < b.length; i++) {
            if (b[i]) {
                sum += myarr[i];
            }
        }

        System.out.println(sum);


    }
}

---

您可以保留重复项目的运行计数，并在运行结束时将其添加到总和中

public class LoopTest {

    public static void main(String[] args) {

        int[] myarr = {12, 12, 12, 8, 15, 15};

        //Boolean array to mark the elements,defaults false 
        boolean[] b = new boolean[myarr.length];

        //Compare Consecutive values and mark them true if equal
        for (int i = 1; i < myarr.length; i++) {
            if (myarr[i - 1] == myarr[i]) {
                b[i - 1] = b[i] = true;
            }
        }
        int sum = 0;

        //Add all the values in myarr with indices marked as equal
        for (int i = 0; i < b.length; i++) {
            if (b[i]) {
                sum += myarr[i];
            }
        }

        System.out.println(sum);


    }
}

你可以用线性效率来解决这个问题。这个程序比较干净，可以在所有条件下工作，检查所有的边缘情况。结果是你的问题的正确答案是66。它在数组中循环，并检查每个元素是否与前一个元素连续相同。如果是，则将元素的值添加到总和上。需要包括边缘情况，以说明每个连续块的起始元素，这些元素也必须添加到总和中

int[] myarr = {12, 12, 12, 8, 15, 15};
// assumes > 0 length
int count = 1;
int sum = 0;
for (int i = 1; i < myarr.length; i++) {
    if (myarr[i] == myarr[i - 1]) {
        count++;
    } else {
        if (count > 1) {
            sum += count * myarr[i - 1];
        }
        count = 1;
    }
}
// handle if last elements are duplicates
if (count > 1) {
    sum += count * myarr[myarr.length - 1];
}
System.out.println(sum);

你可以用线性效率来解决这个问题。这个程序比较干净，可以在所有条件下工作，检查所有的边缘情况。结果是你的问题的正确答案是66。它在数组中循环，并检查每个元素是否与前一个元素连续相同。如果是，则将元素的值添加到总和上。需要包括边缘情况，以说明每个连续块的起始元素，这些元素也必须添加到总和中

int[] myarr = {12, 12, 12, 8, 15, 15};
// assumes > 0 length
int count = 1;
int sum = 0;
for (int i = 1; i < myarr.length; i++) {
    if (myarr[i] == myarr[i - 1]) {
        count++;
    } else {
        if (count > 1) {
            sum += count * myarr[i - 1];
        }
        count = 1;
    }
}
// handle if last elements are duplicates
if (count > 1) {
    sum += count * myarr[myarr.length - 1];
}
System.out.println(sum);

---

以下代码将起作用：

private static int consecutiveCompare(int[] array)
{
    int sum = 0;

    for (int i = 1; i < array.length; i++)
    {
        if (array[i] == array[i-1])
        {
            if (i == 1)
            {
                sum += array[i];
            }
            else if (array[i] != array[i-2])
            {
                sum += array[i];
            }
            sum += array[i];
        }
    }

    return sum;
}

---

以下代码将起作用：

private static int consecutiveCompare(int[] array)
{
    int sum = 0;

    for (int i = 1; i < array.length; i++)
    {
        if (array[i] == array[i-1])
        {
            if (i == 1)
            {
                sum += array[i];
            }
            else if (array[i] != array[i-2])
            {
                sum += array[i];
            }
            sum += array[i];
        }
    }

    return sum;
}

---

尚未测试所有edge案例，以下是我的想法：

public class LoopTest {
    public static void main(String[] args) {
        int[] myarr = {12, 12, 12, 8, 15, 15};
        int sum = 0;
        int occ = 1;
        for (int i = 1; i < myarr.length; i++) {
            if (myarr[i - 1] == myarr[i]) {
                occ++;
            } else {
                if (occ > 1) {
                    sum += (occ * myarr[i - 1]);
                }
                occ = 1;
            }
            if (i == myarr.length - 1) {
                if (occ > 1) {
                    sum += (occ * myarr[i - 1]);
                }
            }
        }
        System.out.println(sum);
    }
}

---

尚未测试所有edge案例，以下是我的想法：

public class LoopTest {
    public static void main(String[] args) {
        int[] myarr = {12, 12, 12, 8, 15, 15};
        int sum = 0;
        int occ = 1;
        for (int i = 1; i < myarr.length; i++) {
            if (myarr[i - 1] == myarr[i]) {
                occ++;
            } else {
                if (occ > 1) {
                    sum += (occ * myarr[i - 1]);
                }
                occ = 1;
            }
            if (i == myarr.length - 1) {
                if (occ > 1) {
                    sum += (occ * myarr[i - 1]);
                }
            }
        }
        System.out.println(sum);
    }
}

---

以前的价值观持有者不是更容易/更干净吗？@Nambari你能给出一个答案吗？我想看看办法@Thinkingcap将在随机位置显示相同的值，如。[1,2,3,1,2,3,4]? 或者总是像[1,1,1,2,2,3,3,4]@Rod_Algonquin如果它们是连续的和相同的，那么在第一种情况下它应该输出0，在第二种情况下13，数组元素可以是随机的，例如{5,6,10,10,3,4,4,4,4,7}是否有一个以前的值持有者更容易/更干净的方法？@Nambari你能给出一个答案吗？我想看看办法@Thinkingcap将在随机位置显示相同的值，如。[1,2,3,1,2,3,4]? 或者总是像[1,1,1,2,2,3,3,4]@Rod_Algonquin一样，如果它们是连续的且相同的，那么在第一种情况下它应该输出0，在第二种情况下13，数组元素可以是随机的，例如{5,6,10,10,3,4,4,4,4,7}在最外层的if中你真的需要i>0吗？你不能用i启动for循环吗=1@Thinkingcap当然，我可以保存一个比较。您的解决方案很简单，一个冗余的比较数组[I]==数组[I-1]，如果数组[I]！=数组[i-2]，您已经开始检查该条件了！你真的需要最外层的i>0吗？你不能用i启动for循环吗=1@Thinkingcap当然，我可以保存一个比较。您的解决方案很简单，一个冗余的比较数组[I]==数组[I-1]，如果数组[I]！=数组[i-2]，您已经开始检查该条件了！很好的方法，但您不需要ifi==myarr.length-1内部循环，请参阅@MikeKobit answerGood方法，但您不需要ifi==myarr.length-1内部循环，请参阅@MikeKobit answer