Hacker Rank Game of Two stacks recursive solution

I was solving problem for game of two stacks on Hackers rank and got stuck. Problem is my solution is not working for other test cases.

https://www.hackerrank.com/challenges/game-of-two-stacks

Alexa has two stacks of non-negative integers, stack A and stack B where index 0 denotes the top of the stack. Alexa challenges Nick to play the following game:

In each move, Nick can remove one integer from the top of either stack A or B stack.

Nick keeps a running sum of the integers he removes from the two stacks.

Nick is disqualified from the game if, at any point, his running sum becomes greater than some integer X given at the beginning of the game.

Nick's final score is the total number of integers he has removed from the two stacks.

find the maximum possible score Nick can achieve (i.e., the maximum number of integers he can remove without being disqualified) during each game and print it on a new line.

For each of the games, print an integer on a new line denoting the maximum possible score Nick can achieve without being disqualified.

Sample input

1 -> Number of games
10 -> sum should not exceed 10 
4 2 4 6 1  -> Stack A
2 1 8 5 -> Stack B

Sample output is

4

My code is :

static int twoStacks(int x, int[] a, int[] b) {
        Stack<Integer> s1 = new Stack<Integer>();
        Stack<Integer> s2 = new Stack<Integer>();

        for(int i=a.length-1; i>=0; i--)
            s1.push(a[i]);

        for(int i=b.length-1; i>=0; i--)
            s2.push(b[i]);    

        return moves(x, s1, s2, 0);
    }
    static int moves(int x, Stack<Integer> a, Stack<Integer> b, int moves){
        
        if(x == 0 ) return moves-1;
        if(x < 0 ) return moves-1;

        int moves1 = a.isEmpty() ? moves : moves(x-a.pop(), a, b, moves+1);
        int moves2 = b.isEmpty() ? moves : moves(x-b.pop(), a, b, moves+1);

        return Math.max(moves1, moves2);

    }

Please can you help me by figuring out what's wrong and what would be the correct recursive approach. A lot of people have solved it by loop method but i want to solve this by recursively. The approach is simple, we have to first traverse the stack one until the required sum is reached then we start approaching the second stack. Whenever sum is greater from required one we delete the last number from the stack 1.

You are using an actual stack and popping (altering) elements, but you are doing a brute force algorithm that relies on the elements not being altered.

I will illustrate using an example:

4 2 4 1  -> Stack A
2 1 8 5 -> Stack B

The correct answer to this question is: StackA[4 2 4 1] StackB[2 1 8 5] = 9 < 10, so 4.

Your answer to this problem will be: StackA[4 2 4 1] StackB[2 1 8 5] = 9 < 10, so 4.

It's the same number, but it's completely wrong. How do we consume that 1 when it's locked behind the 4? This is how it happens:

1. StackA is popped from start. and 4 is added = 4. moves = 1
2. StackA is popped from 1. and 2 is added = 6. moves = 2
3. StackA is popped from 2. and 4 is added = 10. 10 >= 10, so moves-1. moves = 2. Note that 4 has been permanently removed here.
4. StackB is popped from 2. and 2 is added = 8. moves = 3
5. StackA is popped from 4. and 1 is added = 9. moves = 4
   ...
   ...

You can do either of the following:

1. Use a different algorithm that can accommodate the data being altered. This may be the "loop" method you were referring to (haven't seen it so don't know if it is).
2. Use a simulated stack instead of a real one, and simulate the "pop". The simulated stack do not actually remove anything.

Sample code of your code being altered to use a simulated stack:

static int twoStacks(int x, int[] a, int[] b) {
    return moves(x, s1, 0, s2, 0, 0);
}

static int moves(int x, int[] a, int aHead, int[] b, int bHead, int moves){
    if (x <= 0) return moves - 1;

    int moves1 = (aHead < a.length) ? moves(x - a[aHead], a, aHead + 1, b, bHead, moves + 1) : moves;
    int moves2 = (bHead < b.length) ? moves(x - b[bHead], a, aHead, b, bHead + 1, moves + 1) : moves;

    return Math.max(moves1, moves2);
}