How about this logic:

Step I. get the 3 array and reverse them, create a new array out of an existing array with each element is sum of all the previous elements. eg: [3,2,1,1,1] -> [1,1,1,2,3] -> [1,2,3,5,8]

So the 3 new array formed would be [1,2,3,5,8] [2,5,9] [1,5,6,7]

Step II. Again reverse the array [8,5,3,2,1] [9,5,2] [7,6,5,1]

Step III. Take the smallest array i.e. [9,5,2] traverse the smallest array and search element in the other 2 array - if the element is existing in other 2 array, STOP there and return the number.

Eg. Here I start with elem - 9 : Which is not existing in other 2 array. Next I start with elem - 5 : it is existing in other 2 array.

Wolla! 5 is my NUMBER!

Pretty disappointing that the arrays are in the wrong order. It should be in reverse in order to represent a proper stack. Remember, stack is first in last out.

Python 3 solution:

def equalStacks(h1, h2, h3):
    s1, s2, s3 = map(sum, (h1, h2, h3))
    while h1 and h2 and h3:
        m = min(s1, s2, s3)
        while s1 > m: s1 -= h1.pop(0)
        while s2 > m: s2 -= h2.pop(0)
        while s3 > m: s3 -= h3.pop(0)
        if s1 == s2 == s3: return s1
    return 0

Basically, we pop from the two taller stacks until their heights are less than or equal to the shortest stack. If their heights match, we return the height. Otherwise, we continue until any stack is empty, at which point we return 0.

O(n) with stl

int main() {
    int i,na,nb,nc,ma=0,mb=0,mc=0;
    stack<int> a,b,c,sa,sb,sc;
    cin>>na>>nb>>nc;
    for(i=0;i<na;i++){
        int x;
        cin>>x;
        a.push(x);
        ma+=x;
        
    }
    while(!a.empty()){
        sa.push(a.top());
        a.pop();
    }
    for(i=0;i<nb;i++){
        int x;
        cin>>x;
        b.push(x);
        mb+=x;
    }
     while(!b.empty()){
        sb.push(b.top());
        b.pop();
    }
    for(i=0;i<nc;i++){
        int x;
        cin>>x;
        c.push(x);
        mc+=x;
    }
      while(!c.empty()){
        sc.push(c.top());
        c.pop();
    }
    while ( ma != mb || mb != mc  ){
        if(ma>=mb && ma>=mc){
             ma-=sa.top();
             sa.pop();
        }
        else if(mb>=ma && mb>=mc){
            mb-=sb.top();
            sb.pop();
        }
        else{
            mc-=sc.top();
            sc.pop();
        }
    }
    
    cout<<ma;
    return 0;
}

My Java solution using just arrays. It passed all test cases

public class Solution {

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n1 = in.nextInt();
    int n2 = in.nextInt();
    int n3 = in.nextInt();
    int[] numberOfCylinders = {n1, n2, n3};
    int[][] stack = {new int[n1], new int[n2], new int[n3]};
    int[] height = {0, 0, 0}; 
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < numberOfCylinders[i]; j++) {
            int cylinderHeight = in.nextInt();
            stack[i][j] = cylinderHeight;
            height[i] += cylinderHeight;
        }   
    }
    int[] index = {0, 0, 0};
    int targetHeight = Math.min(Math.min(height[0], height[1]), height[2]);
    while (height[0] != height[1] || height[1] != height[2]) {
        for (int i = 0; i < 3; i++) {
            if (height[i] > targetHeight) {
                height[i] -= stack[i][index[i]++]; 
                targetHeight = Math.min(targetHeight, height[i]);
            }
        }
    }
    System.out.println(targetHeight);
}  

}