*(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
}
```