Search a matrix sorted along rows and columns

def search_matrix_ii(matrix, target):
    r, c = 0, len(matrix[0]) - 1       # top-right corner
    while r < len(matrix) and c >= 0:
        v = matrix[r][c]
        if v == target:
            return True
        if v > target:
            c -= 1                     # the whole column below is larger
        else:
            r += 1                     # the whole row to the left is smaller
    return False

#include <vector>

bool solve(const std::vector<std::vector<int>>& matrix, int target) {
    int r = 0, c = (int)matrix[0].size() - 1;   // top-right corner
    while (r < (int)matrix.size() && c >= 0) {
        int v = matrix[r][c];
        if (v == target) return true;
        if (v > target) --c;                    // the column below is larger
        else ++r;                               // the row to the left is smaller
    }
    return false;
}

class Solution {
    public boolean searchMatrixII(int[][] matrix, int target) {
        int r = 0, c = matrix[0].length - 1;    // top-right corner
        while (r < matrix.length && c >= 0) {
            int v = matrix[r][c];
            if (v == target) return true;
            if (v > target) c--;                // the column below is larger
            else r++;                           // the row to the left is smaller
        }
        return false;
    }
}

function searchMatrixII(matrix, target) {
  let r = 0, c = matrix[0].length - 1;   // top-right corner
  while (r < matrix.length && c >= 0) {
    const v = matrix[r][c];
    if (v === target) return true;
    if (v > target) c--;                 // the column below is larger
    else r++;                            // the row to the left is smaller
  }
  return false;
}

fn solve<const C: usize>(matrix: &[[i64; C]], target: i64) -> bool {
    // c counts columns still in play, so it never needs to go below zero
    let (mut r, mut c) = (0usize, C);
    while r < matrix.len() && c > 0 {
        let v = matrix[r][c - 1];              // top-right corner of what is left
        if v == target {
            return true;
        }
        if v > target { c -= 1 } else { r += 1 }
    }
    false
}

import Data.Array

solve :: [[Int]] -> Int -> Bool
solve rows target = go 0 (n - 1)
  where
    m = length rows
    n = length (head rows)
    a = listArray ((0, 0), (m - 1, n - 1)) (concat rows)
    -- (r, c) is the top-right corner of the cells still in play
    go r c
      | r >= m || c < 0 = False
      | v == target     = True
      | v > target      = go r (c - 1)     -- the column below is larger
      | otherwise       = go (r + 1) c     -- the row to the left is smaller
      where v = a ! (r, c)