Эффективность и рекурсия

public class Ex14 {
 
    /**
     * win describes a game process of a certain strategy
     * by which Amir will assure not loosing. 
     * The strategy is as follows: Amir chooses first. Amir always chooses a number in a way
     * that his sum balance will be larger then Tamar sum balance after her turn.
     * He uses his knowledge of Tamar strategy that simply chooses a larger of two numbers. 
     * 
     *  The time complexity is : O(k) when k is number of elements in array,
     *  because every cycle 2 numbers will be chosen and never go back
     *  The space complexity is also O(k)
     * 
     * @param arr - array of numbers
     */ 
    public static void win(int[] arr) {
        
        int sumAmir = 0;
        int sumTamar = 0;
        
        int start = 0;
        int end = arr.length-1; 
        
        while (end - start >= 2) {
            int a = arr[start];
            int b = arr[end];
            int C = arr[start+1];
            int D = arr[end-1];
            boolean amirTook = false;
            
            if ( a>=b ) {
                if (( (sumAmir + a) >= (sumTamar + C)) && ((sumAmir + a) >= (sumTamar + b))) {
                    sumAmir = sumAmir + a;
                    start++;
                    System.out.println("Amir took " + a);
                    amirTook = true;
                }
            } else {
                if (( (sumAmir + b) >= (sumTamar + a)) && ((sumAmir + b) >= (sumTamar + D))) {
                    sumAmir = sumAmir + b;
                    end--;
                    System.out.println("Amir took " + b);
                    amirTook = true;
                }
            }
            
            if (!amirTook) {
                if (a>=b) {
                    sumAmir = sumAmir + a;
                    start++;
                    System.out.println("Amir took " + a);
                    amirTook = true;
                } else {
                    sumAmir = sumAmir + b;
                    end--;
                    System.out.println("Amir took " + b);
                    amirTook = true;
                }
            }
            
            if (arr[start] >= arr[end]) {
                sumTamar = sumTamar + arr[start];
                System.out.println("Tamar took " + arr[start]);
                start++;
            }
            else {
                sumTamar = sumTamar + arr[end];
                System.out.println("Tamar took " + arr[end]);
                end--;              
            }
        }
        
        if (arr[start] >= arr[end]) {
            System.out.println("Amir took " + arr[start]);
            start++;
        }
        else {
            System.out.println("Amir took " + arr[end]);
            end--;
        }
        System.out.println("Tamar took " + arr[start]);
        
        System.out.println("Final Score:");
        System.out.println("Amir total " + (sumAmir + arr[start]));
        System.out.println("Tamar total " + (sumTamar + arr[start]));
    }

int[] ar = {....};  // длинна массива 20
int[] result = new int[10];  // результат
int[] res = new int[10];      // временный результат
int score = 0;
for(int i=2^9; i<2^10;i++) {  // перебираем все возможные варианты
int L=0, R = ar.lenght -1, index =0;  // индексы слева, справа, и заполнения
String[] aStr = Integer.toBinaryString(2^9 + i).split(""); // генерируем вариант перебора
Boolean arB = Arrays.stream(aStr).map(Boolean::getBoolean).toArray(); // работаем с булевыми перем.
for(Boolean b : arB) {  
      if(b) {     // если true берем слева
         res[index] = a[L]; L++; 
      } else {   // если false берем справа
        res[index] = a[R]; R--;
      } index++;
     }
     // ну и дальше проверять очки 
     int score2 = Arrays.stream(res).sum();
    if(score2 > score) {
       // заполнить массив  result значениями их res
    }

public void game(int[] gameField) {
        int amirScore = 0;
        int tamarScore = 0;
        int start = 0;
        int end = gameField.length - 1;
 
        int index = 0;
        int oddsSum = 0;
        int evenSum = 0;
        while (index < gameField.length) {
            evenSum += gameField[index++];
            oddsSum += gameField[index++];
        }
        boolean variant = evenSum > oddsSum;
 
        int value;
        while (start < end) {
 
            value = variant ? (start % 2 == 0 ? gameField[start++] : gameField[end--]) :
                    (start % 2 != 0 ? gameField[start++] : gameField[end--]);
 
            amirScore += value;
            System.out.println("Amir took: " + value);
 
            value = gameField[start] > gameField[end] ? gameField[start++] : gameField[end--];
            tamarScore += value;
            System.out.println("Tamar took: " + value);
        }
        System.out.println("\nFinal score:");
        System.out.println("Amir total: " + amirScore);
        System.out.println("Tamar total: " + tamarScore);
 
    }