(This problem is an interactive problem.)

A binary matrix means that all elements are `0` or `1`. For each individual row of the matrix, this row is sorted in non-decreasing order.

Given a row-sorted binary matrix binaryMatrix, return leftmost column index(0-indexed) with at least a `1` in it. If such index doesn't exist, return `-1`.

You can't access the Binary Matrix directly.  You may only access the matrix using a `BinaryMatrix` interface:

• `BinaryMatrix.get(x, y)` returns the element of the matrix at index `(x, y)` (0-indexed).
• `BinaryMatrix.dimensions()` returns a list of 2 elements `[n, m]`, which means the matrix is `n * m`.

Submissions making more than `1000` calls to `BinaryMatrix.get` will be judged Wrong Answer.  Also, any solutions that attempt to circumvent the judge will result in disqualification.

For custom testing purposes you're given the binary matrix `mat` as input in the following four examples. You will not have access the binary matrix directly.

Example 1:

``````Input: mat = [[0,0],[1,1]]
Output: 0``````

Example 2:

``````Input: mat = [[0,0],[0,1]]
Output: 1 ``````

Example 3:

``````Input: mat = [[0,0],[0,0]]
Output: -1``````

Example 4:

``````Input: mat = [[0,0,0,1],[0,0,1,1],[0,1,1,1]]
Output: 1 ``````

Constraints:

• `1 <= mat.length, mat[i].length <= 100`
• `mat[i][j]` is either `0` or `1`.
• `mat[i]` is sorted in a non-decreasing way.

Solution:

``````/**
* // This is the BinaryMatrix's API interface.
* // You should not implement it, or speculate about its implementation
* type BinaryMatrix struct {
*     Get(int, int) int
*     Dimensions() []int
* }
*/
func binarySearch(b *BinaryMatrix, row, size int) int{
x, y := 0, size -1
for x <= y {
mid := x + (y -x)/2
if (*b).Get(row, mid) == 1 {
y = mid - 1
} else {
x = mid + 1
}
}

if (x <= size -1) && (*b).Get(row, x) == 1  {
return x
}
return -1

}
func leftMostColumnWithOne(binaryMatrix BinaryMatrix) int {
d := binaryMatrix.Dimensions()
result := d[1];
for row:= 0; row < d[0]; row++ {
idx := binarySearch(&binaryMatrix, row, d[1])
if idx != -1 && idx < result {
result = idx
}
}
if result == d[1] {
return -1
}
return result
}``````