Stochastic Hill Climbing

function stochastichillPathfind(grid, start, end, allowDiag, hFn) {
  const h = hFn || HEURISTICS.manhattan;
  const prev = new Map();
  let r = start[0];
  let c = start[1];
  for (let step = 0; step < grid.length * grid[0].length; step++) {
    visitNode(r, c);
    if (r === end[0] && c === end[1]) {
      reconstructPath(prev, start, end);
      return;
    }
    const neighbors = getNeighbors(grid, r, c, allowDiag);
    const better = neighbors.filter(([nr, nc]) => h(nr, nc, end[0], end[1]) < h(r, c, end[0], end[1]));
    if (!better.length) break;
    const __pattern1 = better[Math.floor(Math.random() * better.length)];
    const nr = __pattern1[0];
    const nc = __pattern1[1];
    prev.set(key(nr, nc), [r, c]);
    r = nr;
    c = nc;
    pushFrontier(r, c);
  }
  reportNoPath();
}

def stochastichillPathfind(grid, start, end, allowDiag, hFn):
    h = (hFn or HEURISTICS.manhattan)
    prev = Map()
    r = start[0]
    c = start[1]
    for step in range((grid.length * grid[0].length)):
        visitNode(r, c)
        if ((r == end[0]) and (c == end[1])):
            reconstructPath(prev, start, end)
            return
        neighbors = getNeighbors(grid, r, c, allowDiag)
        better = [_v for _v in neighbors if (h(nr, nc, end[0], end[1]) < h(r, c, end[0], end[1]))]
        if not better.length:
            break
        __pattern1 = better[int((random() * better.length))]
        nr = __pattern1[0]
        nc = __pattern1[1]
        prev.set(key(nr, nc), [r, c])
        r = nr
        c = nc
        pushFrontier(r, c)
    reportNoPath()

#include <vector>
#include <algorithm>
#include <cmath>
void stochastichillPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    auto h = (hFn || HEURISTICS.manhattan);
    auto prev = Map();
    auto r = start[0];
    auto c = start[1];
    for(int step=0; step<(grid.length * grid[0].length); step++) {
        visitNode(r, c);
        if(((r == end[0]) && (c == end[1]))) {
            reconstructPath(prev, start, end);
            return;
        }
        auto neighbors = getNeighbors(grid, r, c, allowDiag);
        std::vector<int> better; for(int _fi=0;_fi<n;_fi++) { int _v=neighbors[_fi]; if((h(nr, nc, end[0], end[1]) < h(r, c, end[0], end[1]))) better.push_back(neighbors[_fi]); }
        if(!better.length) {
            break;
        }
        auto __pattern1 = better[(int)std::floor((std::random() * better.length))];
        auto nr = __pattern1[0];
        auto nc = __pattern1[1];
        prev.set(key(nr, nc), [r, c]);
        r = nr;
        c = nc;
        pushFrontier(r, c);
    }
    reportNoPath();
}

public void stochastichillPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var prev = Map();
    var r = start[0];
    var c = start[1];
    for(int step=0; step<(grid.length * grid[0].length); step++) {
        visitNode(r, c);
        if(((r == end[0]) && (c == end[1]))) {
            reconstructPath(prev, start, end);
            return;
        }
        var neighbors = getNeighbors(grid, r, c, allowDiag);
        int[] better = new int[n]; int better_len=0; for(int _fi=0;_fi<n;_fi++) { int _v=neighbors[_fi]; if((h(nr, nc, end[0], end[1]) < h(r, c, end[0], end[1]))) better[better_len++]=neighbors[_fi]; }
        if(!better.length) {
            break;
        }
        var __pattern1 = better[(int)Math.Floor((double)(random() * better.length))];
        var nr = __pattern1[0];
        var nc = __pattern1[1];
        prev.set(key(nr, nc), [r, c]);
        r = nr;
        c = nc;
        pushFrontier(r, c);
    }
    reportNoPath();
}

#include <stdio.h>
#include <math.h>
void stochastichillPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var prev = Map();
    var r = start[0];
    var c = start[1];
    for(int step=0; step<(grid.length * grid[0].length); step++) {
        visitNode(r, c);
        if(((r == end[0]) && (c == end[1]))) {
            reconstructPath(prev, start, end);
            return;
        }
        var neighbors = getNeighbors(grid, r, c, allowDiag);
        int better[n]; int better_len=0; for(int _fi=0;_fi<n;_fi++) { int _v=neighbors[_fi]; if((h(nr, nc, end[0], end[1]) < h(r, c, end[0], end[1]))) better[better_len++]=neighbors[_fi]; }
        if(!better.length) {
            break;
        }
        var __pattern1 = better[(int)floor((random() * better.length))];
        var nr = __pattern1[0];
        var nc = __pattern1[1];
        prev.set(key(nr, nc), [r, c]);
        r = nr;
        c = nc;
        pushFrontier(r, c);
    }
    reportNoPath();
}