Java Solution: with detailed explanation
Approach We need to have 3 arrays with binary number represented by them should be all equal.  We know that leading '0'(zero) in binary doesn't add value to bin
# Approach
We need to have 3 arrays with binary number represented by them should be all equal.  We know that leading '0'(zero) in binary doesn't add value to binary number, but trailiing zero's do.  So, if we could first count the trailing zeros in the incoming input first.  Then we can try to find 2 other arrays with same number of trailing zeros.  If it's not possible to find such 3 arrays, then we can't find solution.  Also, since we need to slice array into 3 parts, then we need to make sure the incoming arrays contains '1' which are divisible by 3.  

# Algorithm
1.  Get the **SUM** of the array.  If the **SUM** is not divisible by 3 then we can blindly return [-1,-1] as answer.  Otherwise go to step2
2.  If sum is 0 then we can split array in many possible ways, we can use [0,A.length-1] as answer.  You can hardcode some other value as well, it should work. Otherwise, go to step3
3.  Find the trailing zero's in the input.  Lets call it **trailingZeros**.  **targetSum** is equal to **SUM/3**
4.  Now lets iterate through the input and find the 2 split where the running sum of the split array is equal to **targetSum**.  We know there are count of **trailingZeros** at the end.  So, after we find the **targetSum** store the index with **trailingZeros** count added.  Why we add **trailingZeros** count to the first and second split of the array? Reason: If the last array contains those many trailing zeros then other 2 also must contain those, failing to do so means we cannot split the array into 3 parts.
5.  Once we find the 2 splits.  We can iterate through the split and check whether **splitSum** matches **targetSum**?.  Return the [-1,-1] when there is no match.
6.  Last part of the algo:  We found 3 arrays with equals sum, but it's possible that individual binary number formed by split array may not match.  So, lets check the individual bits do they match.  Why we need to match? Reason: Matching them gives a clear indication that binary number formed by 3 are actually equal.

Runtime Complexity is O(N) - N is length of input array.
Space Complexity is O(1) - Constant.
My solution took 11 ms.  
# Code

```
public int[] threeEqualPartsWorking(int[] A) {
		int sum = 0, N = A.length ;
		for(int v : A) sum +=v;
		if(sum  % 3 != 0)
			return new int[]{-1, -1};
		if(sum  == 0){
			return new int[]{0, N - 1};
		}
		int[] ret = new int[]{-1, -1}; // First split and second split index
		int trailingZeros = 0;
		for(int i= N-1;i >= 0;i--){
			if(A[i] == 1){
				trailingZeros = N-1-i;
				break;
			}
		}

		int runningSum= 0, targetSum = sum /3 ;
		for(int i = 0;i < N ;i++){
			runningSum += A[i];
			if(runningSum == targetSum && ret[0] == -1){
					ret[0] = i+trailingZeros;
			}
			if(runningSum == 2*targetSum && ret[1] == -1){
					ret[1] = i+1+trailingZeros;
			}
		}

		if(ret[1] >= N)// if first split has gone beyond the input array length, then we can't split.
			return new int[]{-1, -1};

		int splitSum = 0 ;
		for(int i = 0;i <= ret[0];i++) splitSum += A[i];
		if(splitSum != targetSum)return new int[]{-1,-1};

		splitSum = 0;
		for(int i = ret[0]+1;i < ret[1];i++) splitSum += A[i];
		if(splitSum != targetSum)return new int[]{-1,-1};

		for(int i = N-1, j = ret[1]-1, k = ret[0]; i >= ret[1] && j >= ret[0]+1 && k >= 0; i--,j--,k--){
			int uniqBits = A[i]+A[j]+A[k];
			if(!(uniqBits == 3 || uniqBits == 0))return new int[]{-1, -1};
		}

		return ret;
}
```
[]