Maximum product of 4 adjacent elements in matrix

<script>

// Javascript program to find out the
// maximum product in the matrix
// which four elements are adjacent
// to each other in one direction
let n = 5;

    // function to find max product
    function FindMaxProduct(arr,n)
    {
        let max = 0, result;

        // iterate the rows.
        for (let i = 0; i < n; i++)
        {
            // iterate the columns.
            for (let j = 0; j < n; j++)
            {
                // check the maximum product
                // in horizontal row.
                if ((j - 3) >= 0)
                {
                    result = arr[i][j] * arr[i][j - 1]
                            * arr[i][j - 2]
                            * arr[i][j - 3];
                    if (max < result)
                        max = result;
                }

                // check the maximum product
                // in vertical row.
                if ((i - 3) >= 0)
                {
                    result = arr[i][j] * arr[i - 1][j]
                            * arr[i - 2][j]
                            * arr[i - 3][j];

                    if (max < result)
                        max = result;
                }

                // check the maximum product in
                // diagonal (going through down - right)
                if ((i - 3) >= 0 && (j - 3) >= 0)
                {
                    result = arr[i][j] * arr[i - 1][j - 1]
                            * arr[i - 2][j - 2]
                            * arr[i - 3][j - 3];

                    if (max < result)
                        max = result;
                }

                // check the maximum product in
                // diagonal (going through up - right)
                if ((i - 3) >= 0 && (j - 3) <= 0)
                {
                result = arr[i][j] * arr[i - 1][j + 1]
                            * arr[i - 2][j + 2]
                            * arr[i - 3][j + 3];

                    if (max < result)
                        max = result;
                }
            }
        }

        return max;
    }

    // Driver code
    

        /* int arr[][4] = {{6, 2, 3, 4},
                        {5, 4, 3, 1},
                        {7, 4, 5, 6},
                        {8, 3, 1, 0}};*/
        /* int arr[][5] = {{1, 2, 1, 3, 4},
                        {5, 6, 3, 9, 2},
                        {7, 8, 8, 1, 2},
                        {1, 0, 7, 9, 3},
                        {3, 0, 8, 4, 9}};*/

        let arr = [[ 1, 2, 3, 4, 5 ],
                   [ 6, 7, 8, 9, 1 ],
                   [ 2, 3, 4, 5, 6 ],
                    [ 7, 8, 9, 1, 0 ],
                    [ 9, 6, 4, 2, 3 ]];

        document.write(FindMaxProduct(arr, n));
    
// This code is contributed by sravan kumar

</script>

<script>
// Javascript implementation of the above approach
    
    function maxPro(a,n,m,k)
    {
        let maxi = 1, mp = 1;
        for (let i = 0; i < n; ++i)
        {
            // Window Product for each row.
            let wp = 1;
            for (let l = 0; l < k; ++l)
            {
                wp *= a[i][l];
            }
            
            // Maximum window product for each row
            mp = wp;
            for (let j = k; j < m; ++j)
            {
                wp = wp * a[i][j] / a[i][j - k];
               
                // Global maximum
                // window product
                maxi = Math.max(
                    maxi,
                    Math.max(mp, wp));
            }
        }
        return maxi;
    }
    
    // Driver Code
    let n = 6, m = 5, k = 4;
    let a=[[1, 2, 3, 4, 5 ], [ 6, 7, 8, 9, 1 ],
            [ 2, 3, 4, 5, 6 ], [ 7, 8, 9, 1, 0 ],
            [ 9, 6, 4, 2, 3 ], [ 1, 1, 2, 1, 1 ]]
    // Function call
    let maxpro = maxPro(a, n, m, k);
    document.write(maxpro);
    
    // This code is contributed by rag2127
</script>