How can I add new integers to replace the old integers to my already-existing Array?

Question

Here is the program task:

Write a method called collapse that accepts an array of integers as a parameter and returns a new array containing the result of replacing each pair of integers with the sum of that pair.

For example, if an array called list stores the values
{7, 2, 8, 9, 4, 13, 7, 1, 9, 10}

then the call of collapse(list) should return a new array containing: {9, 17, 17, 8, 19} .

The first pair from the original list is collapsed into 9 (7 + 2), the second pair is collapsed into 17 (8 + 9), and so on. If the list stores an odd number of elements, the final element is not collapsed.

For example, if the list had been {1, 2, 3, 4, 5} , then the call would return {3, 7, 5} . Your method should not change the array that is passed as a parameter.

Here is my currently-written program:

public static int[] collapse(int[] a1) {
    int newArrayLength = a1.length / 2;
    int[] collapsed = new int[newArrayLength];
    int firstTwoSums = 0;
    for (int i = 0; i < a1.length-1; i++) {
        firstTwoSums = a1[i] + a1[i+1];
        collapsed[collapsed.length-1] = firstTwoSums;
    }
    return collapsed;
}

I pass in an array of {7, 2, 8, 9, 4, 13, 7, 1, 9, 10} and I want to replace this array with {9, 17, 17, 8, 19} .
Note: {9, 17, 17, 8, 19} will be obtained through the for-loop that I have written.

Currently, I am having trouble with adding the integers I obtained to my "collapsed" array. It'd be a great help if you could help me or at least give me some guidance on how to do this.

Thanks in advance!

Answer 1

Using

collapsed[collapsed.length-1] = firstTwoSums;

The sum of your numbers will be always be put in the same index of the collapsed array, because collapsed.length - 1 is a constant value.

Try creating a new variable starting at zero, that can be incremented each time you add a sum to collapsed. For instance,

int j = 0;
for(...) {
...
collapsed[j++] = firstTwoSums;
}

Answer 2

First you have to understand what is going on.

You have an array of certain size where size can either be even or odd . This is important because you are using a1.length/2 to set the size for new array , so you will also have to check for odd and even values to set the size right else it won't work for odd sized arrays. Try a few cases for better understanding.

Here's a way of doing it.

public static int[] collapseThis(int[] array) {

    int size = 0;

    if(isEven(array.length))
        size = array.length/2;
    else
        size = array.length/2+1;

    int[] collapsedArray = new int[size];

    for(int i=0, j=0; j<=size-1; i++, j++) {

        if(j==size-1 && !isEven(array.length)) {
            collapsedArray[j] = array[2*i];
        }
        else {
            collapsedArray[j] = array[2*i]+array[2*i+1];
        }
    }
    return collapsedArray;
}

private static boolean isEven(int num) { 
    return (num % 2 == 0); 
}

Answer 3

I think this is a convenient answer.

public static void main(String[] args){
   int[] numbers = {1,2,3,4,5};
   int[] newList = collapse(numbers);
   System.out.println(Arrays.toString(newList));
}

public static int[] collapse(int[] data){
    int[] newList = new int[(data.length + 1)/2];
    int count = 0;
    for (int i = 0; i < (data.length / 2); i++){
       newList[i] = data[count] + data[count + 1];
        System.out.println(newList[i]);
       count = count + 2;
    }
    if (data.length % 2 == 1){   
       newList[(data.length / 2)] = data[data.length - 1];
   }
    return newList;
}

Answer 4

i would combine the cases for the array with either odd or even elements together as below:

public static int[] collapse(int[] a1) {
    int[] res = new int[a1.length/2 + a1.length % 2];
    for (int i = 0; i < a1.length; i++)
         res[i/2] += a1[i];
    return res;

}

Answer 5

public static int[] collapse(int[] a1) {
    int newArrayLength = a1.length / 2;
    int[] collapsed;
    if(a1.length%2 == 0)
    {
        collapsed = new int[newArrayLength];
    }
    else
    {
        collapsed = new int[newArrayLength+1];
        collapsed[newArrayLength] = a1[a1.length-1];
    }
    int firstTwoSums = 0;
    for (int i = 0; i < newArrayLength; i++) {
        firstTwoSums = a1[i*2] + a1[i*2+1];
        collapsed[i] = firstTwoSums;
    }       
    return collapsed;
}

I modified your code and you may try it first.