Метод, не получающий целочисленный массив, должен быть:

Question

У меня есть задание, в котором моему методу передается массив целых чисел, я что-то делаю с ними, а затем рекурсивно вызываю метод для подмножества массива, возвращаемого, когда массив имеет длину 2.

Это кажется, что перед рекурсивной передачей моему методу подмассив arr имеет значение [1,2], но после вызова метод, похоже, получил некоторый массив [9,8,2,4,6,3,5 , 1,7] Может ли это быть переполнение? Понятия не имею, что происходит между печатью и звонком. Спасибо!

Вывод:

array gotten: [1,2,3,4,5] of length: 5
init. should be 0, leftSum: 0 rightSum: 0
Original sums: leftSum: 3 rightSum: 12
Current differnece: 9
Next run: leftSum: 6 rightSum: 9
Current differnece: 3
Next run: leftSum: 10 rightSum: 5
newDiff: 5 greater than current diff: 3
Final sums: leftSum: 6 rightSum: 9
new Fruit Sum: 6
Current array: [1,2,3,4,5] passing subset: [1,2,3] of length: 3


array gotten: [1,2,3] of length: 3
init. should be 0, leftSum: 0 rightSum: 0
Original sums: leftSum: 1 rightSum: 5
Current differnece: 4
Next run: leftSum: 3 rightSum: 3
Current differnece: 0
Next run: leftSum: 6 rightSum: 0
newDiff: 6 greater than current diff: 0
Final sums: leftSum: 3 rightSum: 3
new Fruit Sum: 9
Current array: [1,2,3] passing subset: [1,2] of length: 2


array gotten: [9,8,2,4,6,3,5,1,7] of length: 9
init. should be 0, leftSum: 0 rightSum: 0
Original sums: leftSum: 23 rightSum: 22
Current differnece: 1
Next run: leftSum: 19 rightSum: 18
newDiff: 1 greater than current diff: 1
Final sums: leftSum: 23 rightSum: 22
new Fruit Sum: 22
 passing right side: [6,3,5,1,7] of length: 5


array gotten: [6,3,5,1,7] of length: 5
init. should be 0, leftSum: 0 rightSum: 0
Original sums: leftSum: 9 rightSum: 13
Current differnece: 4
Next run: leftSum: 14 rightSum: 8
newDiff: 6 greater than current diff: 4
Final sums: leftSum: 9 rightSum: 13
new Fruit Sum: 31
Current array: [6,3,5,1,7] passing subset: [6,3] of length: 2


Optimal amount of fruits: 34
Completed in 0 milliseconds

Process finished with exit code 0

Класс здесь:

import java.util.Arrays;

public class Assignment3 {

    static int curMinDifference;
    static int fruitCount;
    static boolean done;
    static int leftSum;
    static int rightSum;
    public int maxFruitCount (int[] sections) {
        fruitCount = 0;
        // Implement your dynamic programming algorithm here
        // You may use helper functions as needed
        fruitCount = playGame(sections);

        return fruitCount;
    }


    public static int playGame(int[] curSections) {
        if (curSections.length == 2) {
            fruitCount += min(curSections[0],curSections[1]);
            return fruitCount;
        }
        System.out.print("array gotten: ");
        printArray(curSections);
        System.out.print( " of length: " + curSections.length);
        int middle = curSections.length/2;
        curMinDifference = 2147483647;
        leftSum = 0;
        rightSum = 0;
        int tempL;
        int tempR;
        done = false;
        System.out.println("\ninit. should be 0, leftSum: " + leftSum + " rightSum: " + rightSum);
        findOriginalSums(curSections, middle);
        tempL = leftSum;
        tempR = rightSum;
        System.out.println("Original sums: leftSum: " + leftSum + " rightSum: " + rightSum);
        updateDifference(leftSum, rightSum);

        while(!done) {
            if (min(leftSum, rightSum) == leftSum) {
                tempL += curSections[middle];
                tempR -= curSections[middle];
                System.out.println("Next run: leftSum: " + tempL + " rightSum: " + tempR);
                updateDifference(tempL, tempR);
                if (!done) {
                    leftSum = tempL;
                    rightSum = tempR;
                    middle++;
                }
            } else if (min(leftSum, rightSum) == rightSum) {
                tempL -= curSections[middle - 1];
                tempR -= curSections[middle - 1];
                System.out.println("Next run: leftSum: " + tempL + " rightSum: " + tempR);
                updateDifference(tempL, tempR);
                if (!done) {
                    leftSum = tempL;
                    rightSum = tempR;
                    middle--;
                }
            }

        }

        System.out.println("Final sums: leftSum: " + leftSum + " rightSum: " + rightSum);
        fruitCount += min(leftSum,rightSum);
        System.out.println("new Fruit Sum: " + fruitCount );

        if(min(leftSum, rightSum) == leftSum){
            System.out.print("Current array: ");
            printArray(curSections);
            int[] arr = Arrays.copyOfRange(curSections,0,middle);
            System.out.print(" passing subset: ");
            printArray(arr);
            System.out.println(" of length: " + arr.length);
            System.out.println("\n");
                return playGame(arr);
        } else {
            int[] a = Arrays.copyOfRange(curSections,middle,curSections.length);
            System.out.print(" passing right side: ");
            printArray(a);
            System.out.println(" of length: " + a.length);
            System.out.println("\n");
            return playGame(a);
        }
    }

    private static void printArray(int[] curSections) {
        System.out.print("[");
        for(int j=0; j<curSections.length; j++) {
            System.out.print(curSections[j] );
            if(j != curSections.length-1){System.out.print(",");}
        }
        System.out.print("]");
    }


    private static void updateDifference(int leftSum, int rightSum) {
        if(differenceOf(leftSum,rightSum) < curMinDifference){
            curMinDifference = differenceOf(leftSum, rightSum);
            System.out.println("Current differnece: " + curMinDifference);
        } else{
            System.out.println("newDiff: " + differenceOf(leftSum,rightSum) + " greater than current diff: " + curMinDifference);
            done = true;
        }
    }

    private static int differenceOf(int leftSum, int rightSum) {
        if(leftSum < rightSum){
            return rightSum-leftSum;
        } else{
            return leftSum-rightSum;
        }
    }

    private static void findOriginalSums(int[] curSections, int middle) {
        for(int i=0; i<middle; i++){
            Assignment3.leftSum += curSections[i];
        }
        for(int i=middle; i<curSections.length; i++){
            Assignment3.rightSum += curSections[i];
        }
    }

    private static int min(int a, int b) {
        if(a<b){
            return a;
        }else {
            return b;
        }
    }
}