Minimum number of cells after, before, above and below NxN squares

From Rosetta Code
Minimum number of cells after, before, above and below NxN squares is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task

Find and show on this page the minimum number of cells after, before, above and below   N×N   squares,   where   N = 10.

11l

Translation of: Python
F min_cells_matrix(siz)
   R (0 .< siz).map(row -> (0 .< @siz).map(col -> min(@row, col, @@siz - @row - 1, @@siz - col - 1)))

F display_matrix(mat)
   V siz = mat.len
   V spaces = I siz < 20 {2} E I siz < 200 {3} E 4
   print("\nMinimum number of cells after, before, above and below "siz‘ x ’siz‘ square:’)
   L(row) 0 .< siz
      print(mat[row].map(n -> String(n).rjust(@spaces)).join(‘’))

L(siz) [23, 10, 9, 2, 1]
   display_matrix(min_cells_matrix(siz))
Output:

Minimum number of cells after, before, above and below 23 x 23 square:
  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
  0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
  0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
  0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 11 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
  0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
  0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
  0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

Minimum number of cells after, before, above and below 10 x 10 square:
 0 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 9 x 9 square:
 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 3 4 3 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 2 x 2 square:
 0 0
 0 0

Minimum number of cells after, before, above and below 1 x 1 square:
 0

ALGOL 68

Translation of: Wren

As with the Algol W version, the cells are printed as they are calculated. Ensures the counts are shown in the same width.

BEGIN # show the minimum number of cells above, below, before and after each #
      # cell in a suare matrix                                               #

    PROC min = ( INT a, b )INT: IF a < b THEN a ELSE b FI;

    PROC print min cells = ( INT n )VOID: 
         BEGIN
            # deduce how many digits we need to show so the counts are all   #
            # the same width                                                 #
            INT w = BEGIN
                        INT width := 1, v := ( ( n - ( ABS NOT ODD n ) ) OVER 2 );
                        WHILE v > 9 DO v OVERAB 10; width +:= 1 OD;
                        width
                    END;
            print( ( "Minimum number of cells after, before, above and below "
                   , whole( n, 0 )
                   , " x "
                   , whole( n, 0 )
                   , " square:"
                   , newline
                   )
                 );
            FOR r FROM 0 TO n - 1 DO
                FOR c FROM 0 TO n - 1 DO print( ( whole( min( n-r-1, min( r, min( c, n-c-1 ) ) ), -w ), " " ) ) OD;
                print( ( newline ) )
            OD
         END # print min cells # ;
 
    []INT tests = ( 10, 9, 2, 1, 21 );
    FOR i FROM LWB tests TO UPB tests DO
        print min cells( tests[ i ] );
        print( ( newline ) )
    OD

END
Output:
Minimum number of cells after, before, above and below 10 x 10 square:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 9 x 9 square:
0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 2 x 2 square:
0 0
0 0

Minimum number of cells after, before, above and below 1 x 1 square:
0

Minimum number of cells after, before, above and below 21 x 21 square:
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

ALGOL W

Translation of: Wren

This version avoids generating an explicit list of elements for each row in the matrix and just prints the elements as they are calculated. The elements are all shown in the same field width.

begin % show the minimum number of cells above, below, before and after each %
      % cell in a square matrix                                              %

    integer procedure min4( integer value a, b, c, d ) ;
    begin
        integer m;
        m := a;
        if b < m then m := b;
        if c < m then m := c;
        if d < m then m := d;
        m
    end min4 ;

    procedure printMinCells ( integer value n ) ; 
    begin
        integer w, v;
        w := 1; v := ( ( n - ( if odd( n ) then 1 else 0 ) ) div 2 );
        while v > 9 do begin v := v div 10; w := w + 1 end;
        write( i_w := 1, s_w := 0, "Minimum number of cells after, before, above and below ", n, " x ", n, " square:" );
        write();
        for r := 0 until n - 1 do begin
            for c := 0 until n - 1 do writeon( i_w := w, s_w := 1, min4( n-r-1, r, c, n-c-1 ) );
            write()
        end for_r
    end printMinCells ;
 
    for n := 10, 9, 2, 1 do printMinCells( n )

end.
Output:
Minimum number of cells after, before, above and below 10 x 10 square:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 9 x 9 square:
0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 2 x 2 square:
0 0
0 0

Minimum number of cells after, before, above and below 1 x 1 square:
0

Minimum number of cells after, before, above and below 21 x 21 square:
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

APL

Works with: Dyalog APL
n_by_n  (⌽⌊⊖)(∘.¯1+⍳)
n_by_n¨ 2 3 9 10
Output:
┌───┬─────┬─────────────────┬───────────────────┐
│0 0│0 0 0│0 0 0 0 0 0 0 0 0│0 0 0 0 0 0 0 0 0 0│
│0 0│0 1 0│0 1 1 1 1 1 1 1 0│0 1 1 1 1 1 1 1 1 0│
│   │0 0 0│0 1 2 2 2 2 2 1 0│0 1 2 2 2 2 2 2 1 0│
│   │     │0 1 2 3 3 3 2 1 0│0 1 2 3 3 3 3 2 1 0│
│   │     │0 1 2 3 4 3 2 1 0│0 1 2 3 4 4 3 2 1 0│
│   │     │0 1 2 3 3 3 2 1 0│0 1 2 3 4 4 3 2 1 0│
│   │     │0 1 2 2 2 2 2 1 0│0 1 2 3 3 3 3 2 1 0│
│   │     │0 1 1 1 1 1 1 1 0│0 1 2 2 2 2 2 2 1 0│
│   │     │0 0 0 0 0 0 0 0 0│0 1 1 1 1 1 1 1 1 0│
│   │     │                 │0 0 0 0 0 0 0 0 0 0│
└───┴─────┴─────────────────┴───────────────────┘

AppleScript

use framework "Foundation"

------------------- DISTANCES FROM EDGE ------------------

-- distancesFromEdge :: Int -> [[Int]]
on distancesFromEdge(n)
    -- A matrix of minimum distances to the edge.
    
    script f
        on |λ|(row, col)
            minimum({row - 1, col - 1, n - row, n - col})
        end |λ|
    end script
    
    matrix(n, n, f)
end distancesFromEdge


--------------------------- TEST -------------------------
on run
    script test
        on |λ|(n)
            showMatrix(my distancesFromEdge(n)) & ¬
                linefeed
        end |λ|
    end script
    
    unlines(map(test, {25, 10, 9, 2, 1}))
end run


------------------------- GENERIC ------------------------

-- matrix :: Int -> Int -> ((Int, Int) -> a) -> [[a]]
on matrix(nRows, nCols, f)
    -- A matrix of a given number of columns and rows,
    -- in which each value is a given function of its
    -- (zero-based) column and row indices.
    script go
        property g : mReturn(f)'s |λ|
        on |λ|(iRow)
            set xs to {}
            repeat with iCol from 1 to nCols
                set end of xs to g(iRow, iCol)
            end repeat
            xs
        end |λ|
    end script
    
    map(go, enumFromTo(1, nRows))
end matrix


-- minimum :: Ord a => [a] -> a
on minimum(xs)
    set ca to current application
    unwrap((ca's NSArray's arrayWithArray:xs)'s ¬
        valueForKeyPath:"@min.self")
end minimum


-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
    if m  n then
        set xs to {}
        repeat with i from m to n
            set end of xs to i
        end repeat
        xs
    else
        {}
    end if
end enumFromTo


-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
    -- 2nd class handler function lifted into 1st class script wrapper. 
    if script is class of f then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn


-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    -- The list obtained by applying f
    -- to each element of xs.
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to |λ|(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map


-- unwrap :: NSValue -> a
on unwrap(nsValue)
    if nsValue is missing value then
        missing value
    else
        set ca to current application
        item 1 of ((ca's NSArray's arrayWithObject:nsValue) as list)
    end if
end unwrap


------------------------ FORMATTING ----------------------

-- showMatrix :: [[Maybe a]] -> String
on showMatrix(rows)
    -- String representation of rows
    -- as a matrix.
    script showRow
        on |λ|(a, row)
            set {maxWidth, prevRows} to a
            script showCell
                on |λ|(acc, cell)
                    set {w, xs} to acc
                    if missing value is cell then
                        {w, xs & ""}
                    else
                        set s to cell as string
                        {max(w, length of s), xs & s}
                    end if
                end |λ|
            end script
            
            set {rowMax, cells} to foldl(showCell, {0, {}}, row)
            {max(maxWidth, rowMax), prevRows & {cells}}
        end |λ|
    end script
    
    set {w, stringRows} to foldl(showRow, {0, {}}, rows)
    script go
        on |λ|(row)
            unwords(map(justifyRight(w, space), row))
        end |λ|
    end script
    
    unlines(map(go, stringRows))
end showMatrix


-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from 1 to lng
            set v to |λ|(v, item i of xs, i, xs)
        end repeat
        return v
    end tell
end foldl


-- justifyRight :: Int -> Char -> String -> String
on justifyRight(n, cFiller)
    script
        on |λ|(txt)
            if n > length of txt then
                text -n thru -1 of ((replicate(n, cFiller) as text) & txt)
            else
                txt
            end if
        end |λ|
    end script
end justifyRight


-- max :: Ord a => a -> a -> a
on max(x, y)
    if x > y then
        x
    else
        y
    end if
end max


-- Egyptian multiplication - progressively doubling a list, appending
-- stages of doubling to an accumulator where needed for binary 
-- assembly of a target length
-- replicate :: Int -> String -> String
on replicate(n, s)
    -- Egyptian multiplication - progressively doubling a list, 
    -- appending stages of doubling to an accumulator where needed 
    -- for binary assembly of a target length
    script p
        on |λ|({n})
            n  1
        end |λ|
    end script
    
    script f
        on |λ|({n, dbl, out})
            if (n mod 2) > 0 then
                set d to out & dbl
            else
                set d to out
            end if
            {n div 2, dbl & dbl, d}
        end |λ|
    end script
    
    set xs to |until|(p, f, {n, s, ""})
    item 2 of xs & item 3 of xs
end replicate


-- unlines :: [String] -> String
on unlines(xs)
    -- A single string formed by the intercalation
    -- of a list of strings with the newline character.
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, linefeed}
    set s to xs as text
    set my text item delimiters to dlm
    s
end unlines


-- until :: (a -> Bool) -> (a -> a) -> a -> a
on |until|(p, f, x)
    set v to x
    set mp to mReturn(p)
    set mf to mReturn(f)
    repeat until mp's |λ|(v)
        set v to mf's |λ|(v)
    end repeat
    v
end |until|


-- unwords :: [String] -> String
on unwords(xs)
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, space}
    set s to xs as text
    set my text item delimiters to dlm
    return s
end unwords
Output:
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  9  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 10 10 10 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 11 11 11 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 11 12 11 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 11 11 11 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 10 10 10 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  9  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

0 0
0 0

0


Arturo

printMinCells: function [n][
    cells: array.of:n 0
    loop 0..dec n 'r [
        loop 0..dec n 'c ->
            cells\[c]: min @[dec n-r, r, c, dec n-c]
        print cells
    ]
]

loop [10 9 2 1] 'n [
    print ["Minimum number of cells after, before, above and below" n "x" n "square:"]
    printMinCells n
    print ""
]
Output:
Minimum number of cells after, before, above and below 10 x 10 square: 
0 0 0 0 0 0 0 0 0 0 
0 1 1 1 1 1 1 1 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 1 1 1 1 1 1 1 0 
0 0 0 0 0 0 0 0 0 0 

Minimum number of cells after, before, above and below 9 x 9 square: 
0 0 0 0 0 0 0 0 0 
0 1 1 1 1 1 1 1 0 
0 1 2 2 2 2 2 1 0 
0 1 2 3 3 3 2 1 0 
0 1 2 3 4 3 2 1 0 
0 1 2 3 3 3 2 1 0 
0 1 2 2 2 2 2 1 0 
0 1 1 1 1 1 1 1 0 
0 0 0 0 0 0 0 0 0 

Minimum number of cells after, before, above and below 2 x 2 square: 
0 0 
0 0 

Minimum number of cells after, before, above and below 1 x 1 square: 
0

AutoHotkey

gridSize := 10

grid := []
loop % gridSize {
    row := A_Index
    loop % gridSize {
        col := A_Index
        grid[row, col] := Min(row, col, gridSize+1-row, gridSize+1-col) - 1
    }
}

for row, obj in Grid {
    for col, v in obj
        result .= v "  "
    result .= "`n"
}
MsgBox % result
Output:
0  0  0  0  0  0  0  0  0  0  
0  1  1  1  1  1  1  1  1  0  
0  1  2  2  2  2  2  2  1  0  
0  1  2  3  3  3  3  2  1  0  
0  1  2  3  4  4  3  2  1  0  
0  1  2  3  4  4  3  2  1  0  
0  1  2  3  3  3  3  2  1  0  
0  1  2  2  2  2  2  2  1  0  
0  1  1  1  1  1  1  1  1  0  
0  0  0  0  0  0  0  0  0  0  

AWK

# syntax: GAWK -f MINIMUM_NUMBER_OF_CELLS_AFTER_BEFORE_ABOVE_AND_BELOW_NXN_SQUARES.AWK
BEGIN {
    leng = split("3,4,9,10,23",arr,",")
    for (k=1; k<=leng; k++) {
      n = arr[k]
      printf("\nDistance to nearest edge: %dx%d\n",n,n)
      for (i=1; i<=n; i++) {
        for (j=1; j<=n; j++) {
          printf("%2d ",min(min(i-1,n-i),min(j-1,n-j)))
        }
        printf("\n")
      }
    }
    exit(0)
}
function min(x,y) { return((x < y) ? x : y) }
Output:
Distance to nearest edge: 3x3
 0  0  0
 0  1  0
 0  0  0

Distance to nearest edge: 4x4
 0  0  0  0
 0  1  1  0
 0  1  1  0
 0  0  0  0

Distance to nearest edge: 9x9
 0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  1  0
 0  1  2  3  3  3  2  1  0
 0  1  2  3  4  3  2  1  0
 0  1  2  3  3  3  2  1  0
 0  1  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0

Distance to nearest edge: 10x10
 0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  2  1  0
 0  1  2  3  4  4  3  2  1  0
 0  1  2  3  4  4  3  2  1  0
 0  1  2  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0

Distance to nearest edge: 23x23
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 11 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

BASIC

Applesoft BASIC

Works with: Chipmunk Basic
100 HOME : REM  100 CLS for Chipmunk Basic
110 n = 10
120 FOR i = 1 TO n
130 FOR j = 1 TO n
140 IF i-1 <= n-i THEN a = i-1 : GOTO 160
150 IF i-1 > n-i THEN a = n-i
160 IF j-1 <= n-j THEN b = j-1 : GOTO 180
170 IF j-1 > n-j THEN b = n-j
180 IF a <= b THEN r = a : GOTO 200
190 IF a > b THEN r = b
200 PRINT r "  ";
210 NEXT j
220 PRINT
230 NEXT i
240 END
Output:
Same as Chipmunk Basic entry.

BASIC256

Translation of: FreeBASIC
function min(a, b)
	if a<=b then return a else return b
end function

subroutine minab(n)
	for i = 1 to n
		for j = 1 to n
			print min(min(i-1, n-i), min(j-1, n-j)); "  ";
		next j
		print
	next i
end subroutine

call minab(10)
end
Output:
Igual que la entrada de FreeBASIC.

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4
Translation of: BASIC256
10 cls
20 call minab(10)
30 end
40 sub min(a,b)
50 if a <= b then min = a else min = b
60 end sub
70 sub minab(n)
80  for i = 1 to n
90   for j = 1 to n
100    print using "##"; min(min(i-1,n-i),min(j-1,n-j));
110   next j
120   print
130  next i
140 end sub
Output:
Same as BASIC256 entry.

FreeBASIC

#define min(a, b) Iif(a<=b,a,b)

sub minab( n as uinteger )
    for i as uinteger = 1 to n
        for j as uinteger = 1 to n
            print using "## ";min( min(i-1, n-i), min(j-1, n-j) );
        next j
        print
    next i
end sub

minab(10)
Output:

0  0  0  0  0  0  0  0  0  0 
0  1  1  1  1  1  1  1  1  0 
0  1  2  2  2  2  2  2  1  0 
0  1  2  3  3  3  3  2  1  0 
0  1  2  3  4  4  3  2  1  0 
0  1  2  3  4  4  3  2  1  0 
0  1  2  3  3  3  3  2  1  0 
0  1  2  2  2  2  2  2  1  0 
0  1  1  1  1  1  1  1  1  0 
0  0  0  0  0  0  0  0  0  0

GW-BASIC

10 N = 10
20 FOR I = 0 TO N - 1
30 IF I < N - 1 - I THEN DI = I ELSE DI = N - 1 - I
40 FOR J = 0 TO N - 1
50 IF J < N - 1 - J THEN DJ = J ELSE DJ = N - 1 - J
60 IF DI < DJ THEN M = DI ELSE M = DJ
70 PRINT USING "##  ";M;
80 NEXT J
90 PRINT
100 NEXT I

Minimal BASIC

Translation of: GW-BASIC
Works with: Commodore BASIC version 3.5
Works with: Nascom ROM BASIC version 4.7
10 REM Minimum number of cells after, before, above and below NxN squares
20 LET N = 10
30 FOR I = 0 TO N-1
40 IF I < N-1-I THEN 70
50 LET D = N-1-I
60 GOTO 80
70 LET D = I
80 FOR J = 0 TO N-1
90 IF J < N-1-J THEN 120
100 LET E = N-1-J
110 GOTO 130
120 LET E = J
130 IF D < E THEN 160
140 LET M = E
150 GOTO 170
160 LET M = D
170 IF M >= 10 THEN 190
180 PRINT " ";
190 PRINT M;
200 NEXT J
210 PRINT
220 NEXT I
230 END

QBasic

Works with: QBasic
Works with: QuickBasic
Translation of: FreeBASIC
DECLARE FUNCTION min! (a!, b!)
DECLARE SUB minab (n!)

CLS
minab (10)
END

FUNCTION min (a, b)
	IF a <= b THEN min = a ELSE min = b
END FUNCTION

SUB minab (n)
	FOR i = 1 TO n
		FOR j = 1 TO n
			PRINT USING "## "; min(min(i - 1, n - i), min(j - 1, n - j));
		NEXT j
		PRINT
	NEXT i
END SUB
Output:
Igual que la entrada de FreeBASIC.

RapidQ

Translation of: FreeBASIC

Introduced extra variables MinI and MinJ, because nested Min functions do not work correctly (why do they not?).

' Minimum number of cells after, before, above and below NxN squares
DECLARE FUNCTION Min(A AS WORD, B AS WORD) AS WORD
DECLARE SUB MinAB(N AS WORD)

CLS
MinAB(10)
END

FUNCTION Min(A AS WORD, B AS WORD) AS WORD
  IF A <= B THEN Min = A ELSE Min = B
END FUNCTION

SUB MinAB(N AS WORD)
  FOR I = 1 TO N
    MinI = Min(I - 1, N - I)
    FOR J = 1 TO N      
      MinJ = Min(J - 1, N - J)
	PRINT FORMAT$("%2d ", Min(MinI, MinJ));
    NEXT J
    PRINT
  NEXT I
END SUB
Output:

To samo, co we FreeBASIC.

 0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  2  1  0
 0  1  2  3  4  4  3  2  1  0
 0  1  2  3  4  4  3  2  1  0
 0  1  2  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0

Tiny BASIC

Translation of: Minimal BASIC
Works with: TinyBasic
10 REM Minimum number of cells after, before, above and below NxN squares
20 LET N=10
30 LET I=0
40 IF I<N-1-I THEN GOTO 70
50 LET D=N-1-I
60 GOTO 80
70 LET D=I
80 LET J=0
90 IF J<N-1-J THEN GOTO 120
100 LET E=N-1-J
110 GOTO 130
120 LET E=J
130 IF D<E THEN GOTO 160
140 LET M=E
150 GOTO 170
160 LET M=D
170 IF M<10 THEN PRINT " ";
180 PRINT M;"  ";
190 LET J=J+1
200 IF J=N THEN GOTO 220
210 GOTO 90
220 PRINT
230 LET I=I+1
240 IF I=N THEN GOTO 260
250 GOTO 40
260 END
Output:
 0   0   0   0   0   0   0   0   0   0
 0   1   1   1   1   1   1   1   1   0
 0   1   2   2   2   2   2   2   1   0
 0   1   2   3   3   3   3   2   1   0
 0   1   2   3   4   4   3   2   1   0
 0   1   2   3   4   4   3   2   1   0
 0   1   2   3   3   3   3   2   1   0
 0   1   2   2   2   2   2   2   1   0
 0   1   1   1   1   1   1   1   1   0
 0   0   0   0   0   0   0   0   0   0

True BASIC

Translation of: QBasic
FUNCTION min (a, b)
    IF a <= b THEN LET min = a ELSE LET min = b
END FUNCTION

SUB minab (n)
    FOR i = 1 TO n
        FOR j = 1 TO n
            PRINT USING "## ": min(min(i - 1, n - i), min(j - 1, n - j));
        NEXT j
        PRINT
    NEXT i
END SUB

CALL minab (10)
END
Output:
Igual que la entrada de QBasic.

Yabasic

Translation of: FreeBASIC
minab(10)
end

sub minab(n)
	for i = 1 to n
		for j = 1 to n
			print min(min(i-1, n-i), min(j-1, n-j)) using ("##");
		next j
		print
	next i
end sub
Output:
Igual que la entrada de FreeBASIC.

BCPL

get "libhdr"

let min(a,b) = a<b -> a, b

let minNbyN(n, cw) be
    for y=0 to n-1
    $(  for x=0 to n-1 do
            writed(min(x, min(n-x-1, min(y, n-y-1))), cw)
        wrch('*N')
    $)
    
let start() be minNbyN(10, 3)
Output:
  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  2  1  0
  0  1  2  3  4  4  3  2  1  0
  0  1  2  3  4  4  3  2  1  0
  0  1  2  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0

BQN

NByN  ⌜˜ 
NByN¨ 23910
Output:
┌─                                                                 
· ┌─      ┌─        ┌─                    ┌─                       
  ╵ 0 0   ╵ 0 0 0   ╵ 0 0 0 0 0 0 0 0 0   ╵ 0 0 0 0 0 0 0 0 0 0    
    0 0     0 1 0     0 1 1 1 1 1 1 1 0     0 1 1 1 1 1 1 1 1 0    
        ┘   0 0 0     0 1 2 2 2 2 2 1 0     0 1 2 2 2 2 2 2 1 0    
                  ┘   0 1 2 3 3 3 2 1 0     0 1 2 3 3 3 3 2 1 0    
                      0 1 2 3 4 3 2 1 0     0 1 2 3 4 4 3 2 1 0    
                      0 1 2 3 3 3 2 1 0     0 1 2 3 4 4 3 2 1 0    
                      0 1 2 2 2 2 2 1 0     0 1 2 3 3 3 3 2 1 0    
                      0 1 1 1 1 1 1 1 0     0 1 2 2 2 2 2 2 1 0    
                      0 0 0 0 0 0 0 0 0     0 1 1 1 1 1 1 1 1 0    
                                        ┘   0 0 0 0 0 0 0 0 0 0    
                                                                ┘  
                                                                  ┘

C

Translation of: FreeBASIC
#include<stdio.h>
#include<stdlib.h>

#define min(a, b) (a<=b?a:b)

void minab( unsigned int n ) {
    int i, j;
    for(i=0;i<n;i++) {
        for(j=0;j<n;j++) {
            printf( "%2d  ", min( min(i, n-1-i), min(j, n-1-j) ));
        }
        printf( "\n" );
    }
    return;
}

int main(void) {
    minab(10);
    return 0;
}
Output:

0   0   0   0   0   0   0   0   0   0  
0   1   1   1   1   1   1   1   1   0  
0   1   2   2   2   2   2   2   1   0  
0   1   2   3   3   3   3   2   1   0  
0   1   2   3   4   4   3   2   1   0  
0   1   2   3   4   4   3   2   1   0  
0   1   2   3   3   3   3   2   1   0  
0   1   2   2   2   2   2   2   1   0  
0   1   1   1   1   1   1   1   1   0  
0   0   0   0   0   0   0   0   0   0

CLU

min = proc [T: type] (a, b: T) returns (T)
      where T has lt: proctype (T,T) returns (bool)
    if a<b
        then return(a)
        else return(b)
    end
end min

min_n_by_n = proc (n: int) returns (array[array[int]])
    ai = array[int]
    aai = array[ai]
    t: aai := aai$[]
    for y: int in int$from_to(0, n-1) do
        aai$addh(t, ai$[])
        for x: int in int$from_to(0, n-1) do
            i: int := min[int](x, min[int](n-x-1, min[int](y, n-y-1)))
            ai$addh(aai$top(t), i)
        end
    end
    return(t)
end min_n_by_n

print_table = proc (s: stream, table: array[array[int]])
    ai = array[int]
    aai = array[ai]
    for line: ai in aai$elements(table) do
        for item: int in ai$elements(line) do 
            stream$puts(s, int$unparse(item) || " ")
        end
        stream$putl(s, "")
    end
end print_table

start_up = proc ()
    print_table(stream$primary_output(), min_n_by_n(10))
end start_up
Output:
0 0 0 0 0 0 0 0 0 0 
0 1 1 1 1 1 1 1 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 1 1 1 1 1 1 1 0 
0 0 0 0 0 0 0 0 0 0

COBOL

       IDENTIFICATION DIVISION.
       PROGRAM-ID. MINIMUM-CELLS-N-BY-N.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 TABLE-SIZE        PIC 99 VALUE 10.
       01 X                 PIC 99.
       01 Y                 PIC 99.
       01 ITEM              PIC 99.
       01 MIN               PIC 99.
       
       01 FMT               PIC ZZ9.
       01 TABLE-LINE        PIC X(72).
       01 LINE-PTR          PIC 99.
       
       PROCEDURE DIVISION.
       BEGIN.
           PERFORM MAKE-LINE VARYING Y FROM 0 BY 1 
               UNTIL Y IS EQUAL TO TABLE-SIZE.
           STOP RUN.
       
       MAKE-LINE.
           MOVE SPACES TO TABLE-LINE.
           MOVE 1 TO LINE-PTR.
           PERFORM ADD-ITEM VARYING X FROM 0 BY 1
               UNTIL X IS EQUAL TO TABLE-SIZE.
           DISPLAY TABLE-LINE.
           
       ADD-ITEM.
           PERFORM FIND-MINIMUM-VALUE.
           MOVE MIN TO FMT.
           STRING FMT DELIMITED BY SIZE INTO TABLE-LINE 
               WITH POINTER LINE-PTR.
       
       FIND-MINIMUM-VALUE.
           MOVE X TO MIN.
           MOVE Y TO ITEM.
           PERFORM CHECK-MINIMUM.
           COMPUTE ITEM = TABLE-SIZE - Y - 1.
           PERFORM CHECK-MINIMUM.
           COMPUTE ITEM = TABLE-SIZE - X - 1.
           PERFORM CHECK-MINIMUM.
       
       CHECK-MINIMUM.
           IF ITEM IS LESS THAN MIN, MOVE ITEM TO MIN.
Output:
  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  2  1  0
  0  1  2  3  4  4  3  2  1  0
  0  1  2  3  4  4  3  2  1  0
  0  1  2  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0

EasyLang

Translation of: Yabasic
proc minab n . .
   for i = 1 to n
      for j = 1 to n
         write lower lower (i - 1) (n - i) lower (j - 1) (n - j)
      .
      print ""
   .
.
numfmt 0 2
minab 10
Output:
 0 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0 0

Excel

LAMBDA

Binding the name distancesToEdge to the following lambda expression in the Name Manager of the Excel WorkBook:

(See LAMBDA: The ultimate Excel worksheet function)

=LAMBDA(n,
    LET(
        lastIndex, n - 1,
        LAMBDA(i, 
            LET(
                x, MOD(i, n),
                y, QUOTIENT(i, n),
                
                evaluate(
                    "MIN({" & 
                        TEXT(x, "0") & "," & 
                        TEXT(y, "0") & "," &
                        TEXT(lastIndex - x, "0") & "," &
                        TEXT(lastIndex - y, "0") &
                    "})"
                )
            )
        )(SEQUENCE(n, n, 0, 1))
    )
)
Output:

The single formula in the cell B2 defines the whole matrix value which spills out to column K and row 11:

fx =distancesToEdge(A2)
A B C D E F G H I J K
1 Dimension
2 10 0 0 0 0 0 0 0 0 0 0
3 0 1 1 1 1 1 1 1 1 0
4 0 1 2 2 2 2 2 2 1 0
5 0 1 2 3 3 3 3 2 1 0
6 0 1 2 3 4 4 3 2 1 0
7 0 1 2 3 4 4 3 2 1 0
8 0 1 2 3 3 3 3 2 1 0
9 0 1 2 2 2 2 2 2 1 0
10 0 1 1 1 1 1 1 1 1 0
11 0 0 0 0 0 0 0 0 0 0
12
13 9 0 0 0 0 0 0 0 0 0
14 0 1 1 1 1 1 1 1 0
15 0 1 2 2 2 2 2 1 0
16 0 1 2 3 3 3 2 1 0
17 0 1 2 3 4 3 2 1 0
18 0 1 2 3 3 3 2 1 0
19 0 1 2 2 2 2 2 1 0
20 0 1 1 1 1 1 1 1 0
21 0 0 0 0 0 0 0 0 0
22
23 2 0 0
24 0 0
25
26 1 0

Delphi

Works with: Delphi version 6.0

The problem is not well described. You have to look at other people's code to understand the problem, which turns out to be something quite different from the description seems to say.

function EdgeDistance(P: TPoint; Size: integer): integer;
{Find the distance to the nearest edge}
begin
Result:=Min(Min(P.X,(Size-1)-P.X),Min(P.Y,(Size-1)-P.Y));
end;


procedure MapMatrix(Memo: TMemo; Size: integer);
{Map each cell in Size X Size matrix}
{with the distance to nearest edge}
var X,Y,E: integer;
var S: string;
begin
Memo.Lines.Add(Format('Map for %d X %d Matrix',[Size,Size]));
S:='';
for Y:=0 to Size-1 do
	begin
	for X:=0 to Size-1 do
		begin
		E:=EdgeDistance(Point(X,Y),Size);
		S:=S+Format('%3d',[E]);
		end;
	S:=S+#$0D#$0A;
	end;
Memo.Lines.Add(S);
end;


procedure ShowEdgeMaps(Memo: TMemo);
{Show a series of maps for matrices of different sizes}
var I: integer;
begin
for I:=3 to 12 do MapMatrix(Memo,I);
end;
Output:
Map for 3 X 3 Matrix
  0  0  0
  0  1  0
  0  0  0

Map for 4 X 4 Matrix
  0  0  0  0
  0  1  1  0
  0  1  1  0
  0  0  0  0

Map for 5 X 5 Matrix
  0  0  0  0  0
  0  1  1  1  0
  0  1  2  1  0
  0  1  1  1  0
  0  0  0  0  0

Map for 6 X 6 Matrix
  0  0  0  0  0  0
  0  1  1  1  1  0
  0  1  2  2  1  0
  0  1  2  2  1  0
  0  1  1  1  1  0
  0  0  0  0  0  0

Map for 7 X 7 Matrix
  0  0  0  0  0  0  0
  0  1  1  1  1  1  0
  0  1  2  2  2  1  0
  0  1  2  3  2  1  0
  0  1  2  2  2  1  0
  0  1  1  1  1  1  0
  0  0  0  0  0  0  0

Map for 8 X 8 Matrix
  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  0
  0  1  2  2  2  2  1  0
  0  1  2  3  3  2  1  0
  0  1  2  3  3  2  1  0
  0  1  2  2  2  2  1  0
  0  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0

Map for 9 X 9 Matrix
  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  1  0
  0  1  2  3  3  3  2  1  0
  0  1  2  3  4  3  2  1  0
  0  1  2  3  3  3  2  1  0
  0  1  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0

Map for 10 X 10 Matrix
  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  2  1  0
  0  1  2  3  4  4  3  2  1  0
  0  1  2  3  4  4  3  2  1  0
  0  1  2  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0

Map for 11 X 11 Matrix
  0  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  3  2  1  0
  0  1  2  3  4  4  4  3  2  1  0
  0  1  2  3  4  5  4  3  2  1  0
  0  1  2  3  4  4  4  3  2  1  0
  0  1  2  3  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0  0

Map for 12 X 12 Matrix
  0  0  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  3  3  2  1  0
  0  1  2  3  4  4  4  4  3  2  1  0
  0  1  2  3  4  5  5  4  3  2  1  0
  0  1  2  3  4  5  5  4  3  2  1  0
  0  1  2  3  4  4  4  4  3  2  1  0
  0  1  2  3  3  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0  0  0


F#

// Minimum number of cells after, before, above and below NxN squares. Nigel Galloway: August 1st., 2021
printfn "%A"   (Array2D.init 10 10 (fun n g->List.min [n;g;9-n;9-g]))
printfn "\n%A" (Array2D.init  9  9 (fun n g->List.min [n;g;8-n;8-g]))
Output:
[[0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
 [0; 1; 1; 1; 1; 1; 1; 1; 1; 0]
 [0; 1; 2; 2; 2; 2; 2; 2; 1; 0]
 [0; 1; 2; 3; 3; 3; 3; 2; 1; 0]
 [0; 1; 2; 3; 4; 4; 3; 2; 1; 0]
 [0; 1; 2; 3; 4; 4; 3; 2; 1; 0]
 [0; 1; 2; 3; 3; 3; 3; 2; 1; 0]
 [0; 1; 2; 2; 2; 2; 2; 2; 1; 0]
 [0; 1; 1; 1; 1; 1; 1; 1; 1; 0]
 [0; 0; 0; 0; 0; 0; 0; 0; 0; 0]]

[[0; 0; 0; 0; 0; 0; 0; 0; 0]
 [0; 1; 1; 1; 1; 1; 1; 1; 0]
 [0; 1; 2; 2; 2; 2; 2; 1; 0]
 [0; 1; 2; 3; 3; 3; 2; 1; 0]
 [0; 1; 2; 3; 4; 3; 2; 1; 0]
 [0; 1; 2; 3; 3; 3; 2; 1; 0]
 [0; 1; 2; 2; 2; 2; 2; 1; 0]
 [0; 1; 1; 1; 1; 1; 1; 1; 0]
 [0; 0; 0; 0; 0; 0; 0; 0; 0]]

Factor

Works with: Factor version 0.99 2021-06-02
USING: io kernel math math.matrices math.vectors prettyprint
sequences ;

: square ( n -- matrix )
    [ <cartesian-square-indices> ] keep 1 - dup
    '[ dup sum _ > [ _ v-n vabs ] when infimum ] matrix-map ;

{ 10 9 2 1 } [ square simple-table. nl ] each
Output:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

0 0
0 0

0

Fermat

Func Min(a, b) = if a<=b then a else b fi.;
n:=10;
Array x[n, n];
[x]:= [<i=1,n> <j=1,n> Min(Min(i-1,n-i),Min(j-1,n-j))];
[x];
Output:

[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, `

   0,  1,  1,  1,  1,  1,  1,  1,  1,  0, `
   0,  1,  2,  2,  2,  2,  2,  2,  1,  0, `
   0,  1,  2,  3,  3,  3,  3,  2,  1,  0, `
   0,  1,  2,  3,  4,  4,  3,  2,  1,  0, `
   0,  1,  2,  3,  4,  4,  3,  2,  1,  0, `
   0,  1,  2,  3,  3,  3,  3,  2,  1,  0, `
   0,  1,  2,  2,  2,  2,  2,  2,  1,  0, `
   0,  1,  1,  1,  1,  1,  1,  1,  1,  0, `
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0   ]]

Go

Translation of: Wren
package main

import "fmt"

func printMinCells(n int) {
    fmt.Printf("Minimum number of cells after, before, above and below %d x %d square:\n", n, n)
    p := 1
    if n > 20 {
        p = 2
    }
    for r := 0; r < n; r++ {
        cells := make([]int, n)
        for c := 0; c < n; c++ {
            nums := []int{n - r - 1, r, c, n - c - 1}
            min := n
            for _, num := range nums {
                if num < min {
                    min = num
                }
            }
            cells[c] = min
        }
        fmt.Printf("%*d \n", p, cells)
    }
}

func main() {
    for _, n := range []int{23, 10, 9, 2, 1} {
        printMinCells(n)
        fmt.Println()
    }
}
Output:
Minimum number of cells after, before, above and below 23 x 23 square:
[ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0] 
[ 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0] 
[ 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0] 
[ 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0] 
[ 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0] 
[ 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  7  8  9 10 11 10  9  8  7  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0] 
[ 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0] 
[ 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0] 
[ 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0] 
[ 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0] 
[ 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0] 
[ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0] 

Minimum number of cells after, before, above and below 10 x 10 square:
[0 0 0 0 0 0 0 0 0 0] 
[0 1 1 1 1 1 1 1 1 0] 
[0 1 2 2 2 2 2 2 1 0] 
[0 1 2 3 3 3 3 2 1 0] 
[0 1 2 3 4 4 3 2 1 0] 
[0 1 2 3 4 4 3 2 1 0] 
[0 1 2 3 3 3 3 2 1 0] 
[0 1 2 2 2 2 2 2 1 0] 
[0 1 1 1 1 1 1 1 1 0] 
[0 0 0 0 0 0 0 0 0 0] 

Minimum number of cells after, before, above and below 9 x 9 square:
[0 0 0 0 0 0 0 0 0] 
[0 1 1 1 1 1 1 1 0] 
[0 1 2 2 2 2 2 1 0] 
[0 1 2 3 3 3 2 1 0] 
[0 1 2 3 4 3 2 1 0] 
[0 1 2 3 3 3 2 1 0] 
[0 1 2 2 2 2 2 1 0] 
[0 1 1 1 1 1 1 1 0] 
[0 0 0 0 0 0 0 0 0] 

Minimum number of cells after, before, above and below 2 x 2 square:
[0 0] 
[0 0] 

Minimum number of cells after, before, above and below 1 x 1 square:
[0] 

Haskell

import Data.List.Split (chunksOf)

----------- SHORTEST DISTANCES TO EDGE OF MATRIX ---------

distancesToEdge :: Int -> [[Int]]
distancesToEdge n =
  ( \i ->
      chunksOf n $
        (\(x, y) -> minimum [x, y, i - x, i - y])
          <$> (fmap (,) >>= (<*>)) [0 .. i]
  )
    $ pred n

--------------------------- TEST -------------------------
main :: IO ()
main =
  mapM_ putStrLn $
    showMatrix . distancesToEdge <$> [10, 9, 2, 1]

------------------------- DISPLAY ------------------------

showMatrix :: Show a => [[a]] -> String
showMatrix m =
  let w = (succ . maximum) $ fmap (length . show) =<< m
      rjust n c = (drop . length) <*> (replicate n c <>)
   in unlines (unwords . fmap (rjust w ' ' . show) <$> m)
Output:
 0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  2  1  0
 0  1  2  3  4  4  3  2  1  0
 0  1  2  3  4  4  3  2  1  0
 0  1  2  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0

 0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  1  0
 0  1  2  3  3  3  2  1  0
 0  1  2  3  4  3  2  1  0
 0  1  2  3  3  3  2  1  0
 0  1  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0

 0  0
 0  0

 0

or in terms of Data.Matrix:

import Data.Matrix ( matrix, Matrix )

----------- SHORTEST DISTANCES TO EDGE OF MATRIX ---------

distancesToEdge :: Int -> Matrix Int
distancesToEdge n = matrix n n
  (\(i, j) -> minimum $ ($) <$> [pred, (n -)] <*> [i, j])


--------------------------- TEST -------------------------
main :: IO ()
main = mapM_ print $ distancesToEdge <$> [10, 9, 2, 1]
Output:
┌                     ┐
│ 0 0 0 0 0 0 0 0 0 0 │
│ 0 1 1 1 1 1 1 1 1 0 │
│ 0 1 2 2 2 2 2 2 1 0 │
│ 0 1 2 3 3 3 3 2 1 0 │
│ 0 1 2 3 4 4 3 2 1 0 │
│ 0 1 2 3 4 4 3 2 1 0 │
│ 0 1 2 3 3 3 3 2 1 0 │
│ 0 1 2 2 2 2 2 2 1 0 │
│ 0 1 1 1 1 1 1 1 1 0 │
│ 0 0 0 0 0 0 0 0 0 0 │
└                     ┘
┌                   ┐
│ 0 0 0 0 0 0 0 0 0 │
│ 0 1 1 1 1 1 1 1 0 │
│ 0 1 2 2 2 2 2 1 0 │
│ 0 1 2 3 3 3 2 1 0 │
│ 0 1 2 3 4 3 2 1 0 │
│ 0 1 2 3 3 3 2 1 0 │
│ 0 1 2 2 2 2 2 1 0 │
│ 0 1 1 1 1 1 1 1 0 │
│ 0 0 0 0 0 0 0 0 0 │
└                   ┘
┌     ┐
│ 0 0 │
│ 0 0 │
└     ┘
┌   ┐
│ 0 │
└   ┘

or bypassing 'minimum', to reduce the count of comparisons (same output as above):

import Data.Bifunctor (bimap)
import Data.Matrix (Matrix, matrix)

----------- SHORTEST DISTANCES TO EDGE OF MATRIX ---------

distancesToEdge :: Int -> Matrix Int
distancesToEdge n = matrix n n (uncurry min . bimap f f)
  where
    m = quot n 2
    f i
      | i <= m = pred i
      | otherwise = n - i

--------------------------- TEST -------------------------
main :: IO ()
main = mapM_ print $ distancesToEdge <$> [10, 9, 2, 1]

J

nByN=: (|."1<.|.)@(<./~@i.)
nByN each 2 3 9 10
Output:
┌───┬─────┬─────────────────┬───────────────────┐
│0 0│0 0 0│0 0 0 0 0 0 0 0 0│0 0 0 0 0 0 0 0 0 0│
│0 0│0 1 0│0 1 1 1 1 1 1 1 0│0 1 1 1 1 1 1 1 1 0│
│   │0 0 0│0 1 2 2 2 2 2 1 0│0 1 2 2 2 2 2 2 1 0│
│   │     │0 1 2 3 3 3 2 1 0│0 1 2 3 3 3 3 2 1 0│
│   │     │0 1 2 3 4 3 2 1 0│0 1 2 3 4 4 3 2 1 0│
│   │     │0 1 2 3 3 3 2 1 0│0 1 2 3 4 4 3 2 1 0│
│   │     │0 1 2 2 2 2 2 1 0│0 1 2 3 3 3 3 2 1 0│
│   │     │0 1 1 1 1 1 1 1 0│0 1 2 2 2 2 2 2 1 0│
│   │     │0 0 0 0 0 0 0 0 0│0 1 1 1 1 1 1 1 1 0│
│   │     │                 │0 0 0 0 0 0 0 0 0 0│
└───┴─────┴─────────────────┴───────────────────┘

jq

Works with: jq

Also works with gojq, the Go implementation of jq

Also works with fq, a Go implementation of a large subset of jq

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

def printMinCells:
  "Minimum number of cells after, before, above and below each cell in a \(.) x \(.) matrix:",
  ( (. / 2 | ceil | tostring | length) as $p
    | range(0; .) as $r
    | [ range(0; .) as $c
        | [. - $r - 1, $r, $c, . - $c - 1] | min | lpad($p)] | join(" ") );

23, 10, 9, 2, 1
|  printMinCells, ""
Output:

As expected.

Julia

function printNbyN(sizes)
    for N in sizes
        mat = zeros(Int, N, N)
        println("\n\nMinimum number of cells after, before, above and below $N x $N square:")
        for r in 1:N, c in 1:N
             mat[r, c] = min(r - 1, c - 1, N - r, N - c)
        end
        display(mat)
    end
end
 
printNbyN([23, 10, 9, 2, 1])
Output:
  
Minimum number of cells after, before, above and below 23 x 23 square:
23×23 Matrix{Int64}:
 0  0  0  0  0  0  0  0  0  0   0   0   0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1   1   1   1  1  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  2  2   2   2   2  2  2  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  3  3  3   3   3   3  3  3  3  3  3  3  3  2  1  0
 0  1  2  3  4  4  4  4  4  4   4   4   4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5   5   5   5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6   6   6   6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7   7   7   7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8   8   8   8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9   9   9   9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  10  10  10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  10  11  10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  10  10  10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9   9   9   9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8   8   8   8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7   7   7   7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6   6   6   6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5   5   5   5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  4  4  4  4  4   4   4   4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  3  3  3  3  3  3   3   3   3  3  3  3  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  2  2   2   2   2  2  2  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  1   1   1   1  1  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0   0   0   0  0  0  0  0  0  0  0  0  0  0

Minimum number of cells after, before, above and below 10 x 10 square:
10×10 Matrix{Int64}:
 0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  2  1  0
 0  1  2  3  4  4  3  2  1  0
 0  1  2  3  4  4  3  2  1  0
 0  1  2  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0

Minimum number of cells after, before, above and below 9 x 9 square:
9×9 Matrix{Int64}:
 0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  1  0
 0  1  2  3  3  3  2  1  0
 0  1  2  3  4  3  2  1  0
 0  1  2  3  3  3  2  1  0
 0  1  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0

Minimum number of cells after, before, above and below 2 x 2 square:
2×2 Matrix{Int64}:
 0  0
 0  0

Minimum number of cells after, before, above and below 1 x 1 square:
1×1 Matrix{Int64}:
 0

MiniZinc

%Minimum number of cells after, before, above and below NxN squares. Nigel Galloway, August 3rd., 2021
int: Size=10; int: S=Size-1; set of int: N=0..S;
array[N,N] of var int: G = array2d(N,N,[min([n,g,S-n,S-g])|n,g in N]);
output([show2d(G)])
Output:
[| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
   0, 1, 1, 1, 1, 1, 1, 1, 1, 0 |
   0, 1, 2, 2, 2, 2, 2, 2, 1, 0 |
   0, 1, 2, 3, 3, 3, 3, 2, 1, 0 |
   0, 1, 2, 3, 4, 4, 3, 2, 1, 0 |
   0, 1, 2, 3, 4, 4, 3, 2, 1, 0 |
   0, 1, 2, 3, 3, 3, 3, 2, 1, 0 |
   0, 1, 2, 2, 2, 2, 2, 2, 1, 0 |
   0, 1, 1, 1, 1, 1, 1, 1, 1, 0 |
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |]
----------
Finished in 209msec

Modula-2

MODULE MinNByN;
FROM InOut IMPORT WriteCard, WriteLn;

PROCEDURE minNbyN(n, cellwidth: CARDINAL);
    VAR x, y: CARDINAL;
    
    PROCEDURE min(a, b: CARDINAL): CARDINAL;
    BEGIN
        IF a < b THEN RETURN a;
        ELSE RETURN b;
        END;
    END min;
BEGIN
    FOR y := 0 TO n-1 DO
        FOR x := 0 TO n-1 DO
            WriteCard(min(x, min(n-x-1, min(y, n-y-1))), cellwidth);
        END;
        WriteLn();
    END;
END minNbyN;

BEGIN
    minNbyN(10, 3);
END MinNByN.
Output:
  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  2  1  0
  0  1  2  3  4  4  3  2  1  0
  0  1  2  3  4  4  3  2  1  0
  0  1  2  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0

Nim

Translation of: Go
import strutils

proc printMinCells(n: Positive) =
  echo "Minimum number of cells after, before, above and below $1 x $1 square:".format(n)
  var cells = newSeq[int](n)
  for r in 0..<n:
    for c in 0..<n:
      cells[c] = min([n - r - 1, r, c, n - c - 1])
    echo cells.join(" ")

when isMainModule:
  for n in [10, 9, 2, 1]:
    printMinCells(n)
    echo()
Output:
Minimum number of cells after, before, above and below 10 x 10 square:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 9 x 9 square:
0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 2 x 2 square:
0 0
0 0

Minimum number of cells after, before, above and below 1 x 1 square:
0

PARI/GP

n=10
matrix(n,n,i,j,min(min(i-1,n-i),min(j-1,n-j)))
Output:

[0 0 0 0 0 0 0 0 0 0]

[0 1 1 1 1 1 1 1 1 0]

[0 1 2 2 2 2 2 2 1 0]

[0 1 2 3 3 3 3 2 1 0]

[0 1 2 3 4 4 3 2 1 0]

[0 1 2 3 4 4 3 2 1 0]

[0 1 2 3 3 3 3 2 1 0]

[0 1 2 2 2 2 2 2 1 0]

[0 1 1 1 1 1 1 1 1 0]

[0 0 0 0 0 0 0 0 0 0]

Pascal

Using symmetry within row and col.Fill only the middle and let the values before in place.

program mindistance;
{$IFDEF FPC} //used fpc 3.2.1
  {$MODE DELPHI}  {$OPTIMIZATION ON,ALL}  {$COPERATORS ON}
{$ELSE}
  {$APPTYPE CONSOLE}
{$ENDIF}
uses
  sysutils
{$IFDEF WINDOWS},Windows{$ENDIF}
  ;

type
  tMinDist = array of Uint32;
  tpMinDist= pUint32;
var
  dgtwidth : NativeUint;
  OneRowElems : tMinDist;

function CalcDigitWidth(n: NativeUint):NativeUint;
begin
  result:= 2;
  while n>= 10 do
  Begin
    inc(result);
    n := n DIV 10;
  end;
end;

procedure OutOneRow(var OneRowElems:tMinDist);
var
  one_digit,one_row :string;
  i : NativeInt;
begin
  one_row:= '';
  For i := low(OneRowElems) to High(OneRowElems) do
  begin
    str(OneRowElems[i]:dgtwidth,one_digit);
    one_row += one_digit;
  end;
  writeln(one_row);
end;

procedure OutSquareDist(MaxCoor : NativeUInt);
var
  pRes : tpMinDist;
  min_dist,row : NativeInt;
begin
  //iniated with 0
  setlength(OneRowElems,MaxCoor);
  MaxCoor -= 1;//= High(OneRowElems);
  pRes := @OneRowElems[0];

  row := MaxCoor;
  repeat
    min_dist := MaxCoor-row;
    if min_dist > row  then
      min_dist := row;
    //fill the inner rest with min_dist
    FillDWord(pRes[min_dist],(MaxCoor-2*min_dist+1),min_dist);

    OutOneRow(OneRowElems);

    dec(row);
  until row < 0;
  writeln;
  setlength(OneRowElems,0);
end;

procedure Test(MaxCoor:NativeInt);
begin
  if MaxCoor<= 0 then
    EXIT;
  write('Minimum number of cells after, before, above and below ');
  writeln(MaxCoor,' x ',MaxCoor,' square:');
  dgtwidth := CalcDigitWidth(NativeUint(MaxCoor) DIV 2);
  OutSquareDist(MaxCoor);
end;

Begin
//  Test(200*1000);// without output TIO.RUN Real time: 4.152 s CPU share: 97.70 %
  Test(23);
  Test(10);
  Test(9);
  Test(1);
end.
Output:
TIO.RUN
Minimum number of cells after, before, above and below 23 x 23 square:
  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
  0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
  0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
  0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 11 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
  0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
  0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
  0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

Minimum number of cells after, before, above and below 10 x 10 square:
 0 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 9 x 9 square:
 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 3 4 3 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 1 x 1 square:
 0

Perl

use strict;
use warnings;
use List::Util qw( max min );

for my $N (0, 1, 2, 6, 9, 23) {
    my $fmt = ('%' . (1+length int $N/2) . 'd') x $N . "\n";
    print "$N x $N distance to nearest edge:\n";
    for my $row ( 0 .. $N-1 ) {
        my @cols = map { min $_, $row, $N-1 - max $_, $row } 0 .. $N-1;
        printf $fmt, @cols;
    }
    print "\n";
}
Output:
0 x 0 distance to nearest edge:

1 x 1 distance to nearest edge:
 0

2 x 2 distance to nearest edge:
 0 0
 0 0

6 x 6 distance to nearest edge:
 0 0 0 0 0 0
 0 1 1 1 1 0
 0 1 2 2 1 0
 0 1 2 2 1 0
 0 1 1 1 1 0
 0 0 0 0 0 0

9 x 9 distance to nearest edge:
 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 3 4 3 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0

23 x 23 distance to nearest edge:
  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
  0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
  0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
  0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 11 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
  0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
  0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
  0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

Phix

with javascript_semantics
procedure distance_to_edge(integer n)
    printf(1,"Minimum number of cells after, before, above and below %d x %d square:\n",n)
    for r=1 to n do
        for c=1 to n do
            printf(1,"%2d",min({r-1,c-1,n-r,n-c}))
        end for
        printf(1,"\n")
    end for 
end procedure
papply({23,10,9,2,1},distance_to_edge)
Output:
Minimum number of cells after, before, above and below 23 x 23 square:
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0
 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0
 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0
 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0
 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 7 8 9101010 9 8 7 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 7 8 9101110 9 8 7 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 7 8 9101010 9 8 7 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0
 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0
 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0
 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0
 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0
 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Minimum number of cells after, before, above and below 10 x 10 square:
 0 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0 0
Minimum number of cells after, before, above and below 9 x 9 square:
 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 3 4 3 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0
Minimum number of cells after, before, above and below 2 x 2 square:
 0 0
 0 0
Minimum number of cells after, before, above and below 1 x 1 square:
 0

Although I rather like it the way it is, you could argue there should be more spacing on the 23x23, if you insist do this before the loops and use fmt on the innermost line:

    string fmt = sprintf("%%%dd",length(sprint(floor((n-1)/2)))+1)

or maybe just (good for n<=200 whereas the above goes on and on to "%4d", etc.)

    string fmt = iff(n<=20?"%2d":"%3d")

PILOT

C :size=10
  :y=0
*line
C :$l=
  :x=0
*item
C :sy=(size-y)-1
  :sx=(size-x)-1
  :i=x
C (y<i):i=y
C (sy<i):i=sy
C (sx<i):i=sx
  :$l=$l #i
  :x=x+1
J (x<size):*item
T :$l
C :y=y+1
J (y<size):*line
E :
Output:
 0 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0 0

Python

def min_cells_matrix(siz):
    return [[min(row, col, siz - row - 1, siz - col - 1) for col in range(siz)] for row in range(siz)]

def display_matrix(mat):
    siz = len(mat)
    spaces = 2 if siz < 20 else 3 if siz < 200 else 4
    print(f"\nMinimum number of cells after, before, above and below {siz} x {siz} square:")
    for row in range(siz):
        print("".join([f"{n:{spaces}}" for n in mat[row]]))

def test_min_mat():
    for siz in [23, 10, 9, 2, 1]:
        display_matrix(min_cells_matrix(siz))

if __name__ == "__main__":
    test_min_mat()
Output:
Minimum number of cells after, before, above and below 23 x 23 square:
  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
  0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
  0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
  0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
  0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
  0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
  0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 11 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
  0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
  0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
  0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
  0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
  0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
  0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

Minimum number of cells after, before, above and below 10 x 10 square:
 0 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 4 4 3 2 1 0
 0 1 2 3 3 3 3 2 1 0
 0 1 2 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 9 x 9 square:
 0 0 0 0 0 0 0 0 0
 0 1 1 1 1 1 1 1 0
 0 1 2 2 2 2 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 3 4 3 2 1 0
 0 1 2 3 3 3 2 1 0
 0 1 2 2 2 2 2 1 0
 0 1 1 1 1 1 1 1 0
 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 2 x 2 square:
 0 0
 0 0

Minimum number of cells after, before, above and below 1 x 1 square:
 0

Or, disentangling computation from IO (separating model from display), and composing from generics:

'''Distance to edge of matrix'''

from itertools import chain, product


# distancesToEdge :: Int -> [[Int]]
def distancesToEdge(n):
    '''A square matrix of dimension n, in which each
       value is the minimum distance from the matrix
       position to the edge of the matrix.
    '''
    lastIndex = n - 1
    axis = range(0, n)
    return chunksOf(n)([
        min(x, y, lastIndex - x, lastIndex - y)
        for (x, y) in product(axis, axis)
    ])


# ------------------------- TEST -------------------------
# main :: IO ()
def main():
    '''Square matrices of distances to the matrix edge.
       Sample matrices of dimensions [10, 9, 2, 1].
    '''
    print('\n\n'.join([
        showMatrix(distancesToEdge(n)) for n
        in [10, 9, 2, 1]
    ]))


# ----------------------- DISPLAY ------------------------

# showMatrix :: [[Int]] -> String
def showMatrix(xs):
    '''String representation of xs
       as a matrix.
    '''
    def go():
        rows = [[str(x) for x in row] for row in xs]
        w = max(map(len, chain.from_iterable(rows)))
        return "\n".join(
            " ".join(k.rjust(w, ' ') for k in row)
            for row in rows
        )
    return go() if xs else ''


# ----------------------- GENERIC ------------------------

# chunksOf :: Int -> [a] -> [[a]]
def chunksOf(n):
    '''A series of lists of length n, subdividing the
       contents of xs. Where the length of xs is not evenly
       divisible, the final list will be shorter than n.
    '''
    def go(xs):
        return [
            xs[i:n + i] for i in range(0, len(xs), n)
        ] if 0 < n else None
    return go


# MAIN ---
if __name__ == '__main__':
    main()
Output:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

0 0
0 0

0

and in terms of a generalized matrix function:

'''Minimum distances to edge of matrix'''

from itertools import chain


# distanceFromEdge :: Int -> [[Int]]
def distanceFromEdge(n):
    '''A matrix of minimum distances to the
       edge of the matrix.
    '''
    return matrix(n)(n)(
        lambda row, col: min([
            row - 1, col - 1,
            n - row, n - col
        ])
    )


# ------------------------- TEST -------------------------
# main :: IO ()
def main():
    '''Test'''
    for n in [10, 9, 2, 1]:
        print(
            showMatrix(
                distanceFromEdge(n)
            ) + "\n"
        )


# ----------------------- GENERIC ------------------------

# matrix :: Int -> Int -> ((Int, Int) -> a) -> [[a]]
def matrix(nRows):
    '''A matrix of a given number of columns and rows,
       in which each value is a given function over the
       tuple of its (one-based) row and column indices.
    '''
    def go(nCols):
        def g(f):
            return [
                [f(y, x) for x in range(1, 1 + nCols)]
                for y in range(1, 1 + nRows)
            ]
        return g
    return go


# showMatrix :: [[Int]] -> String
def showMatrix(xs):
    '''String representation of xs
       as a matrix.
    '''
    def go():
        rows = [[str(x) for x in row] for row in xs]
        w = max(map(len, chain.from_iterable(rows)))
        return "\n".join(
            " ".join(k.rjust(w, ' ') for k in row)
            for row in rows
        )
    return go() if xs else ''


# MAIN ---
if __name__ == '__main__':
    main()
Output:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

0 0
0 0

0

Raku

sub distance-to-edge (\N) {
   my $c = ceiling N / 2;
   my $f = floor   N / 2;
   my @ul = ^$c .map: -> $x { [ ^$c .map: { min($x, $_) } ] }
   @ul[$_].append: reverse @ul[$_; ^$f] for ^$c;
   @ul.push: [ reverse @ul[$_] ] for reverse ^$f;
   @ul
}
 
for 0, 1, 2, 6, 9, 23 {
    my @dte = .&distance-to-edge;
    my $max = chars max flat @dte».Slip;
 
    say "\n$_ x $_ distance to nearest edge:";
    .fmt("%{$max}d").say for @dte;
}
Output:
0 x 0 distance to nearest edge:

1 x 1 distance to nearest edge:
0

2 x 2 distance to nearest edge:
0 0
0 0

6 x 6 distance to nearest edge:
0 0 0 0 0 0
0 1 1 1 1 0
0 1 2 2 1 0
0 1 2 2 1 0
0 1 1 1 1 0
0 0 0 0 0 0

9 x 9 distance to nearest edge:
0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

23 x 23 distance to nearest edge:
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 11 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

REXX

This REXX version automatically adjusts the width of each (cell) number displayed so that all displayed numbers are aligned.

/*REXX pgm finds the minimum# of cells after, before, above, & below a NxN square matrix*/
parse arg $                                      /*obtain optional arguments from the CL*/
if $='' | $=","  then $= 21 10 9 2 1             /*Not specified?  Then use the default.*/
             @title= ' the minimum number of cells after, before, above, and below a '
  do j=1  for words($);     g= word($, j)        /*process each of the squares specified*/
  w= length( (g-1) % 2)                          /*width of largest number to be shown. */
  say center(@title g"x"g ' square matrix ', 86) /*center title of output to be shown.  */
  say center('',    86, '─')                     /*display a separator line below title.*/

     do     r=0  for g                           /*process output for a  NxN  sq. matrix*/
     _= left('', max(0, 85%(w+1) -g ) )          /*compute indentation output centering.*/
         do c=0  for g
         _= _ right( min(r, c, g-r-1, g-c-1), w) /*construct a row of the output matrix.*/
         end   /*c*/
     say _                                       /*display a row of the output square.  */
     end       /*r*/

   say;  say                                     /*display 2 blank lines between outputs*/
   end         /*j*/                             /*stick a fork in it,  we're all done. */
output   when using the default inputs:
 the minimum number of cells after, before, above, and below a  21x21  square matrix
──────────────────────────────────────────────────────────────────────────────────────
         0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
         0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
         0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
         0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
         0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
         0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
         0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
         0  1  2  3  4  5  6  7  7  7  7  7  7  7  6  5  4  3  2  1  0
         0  1  2  3  4  5  6  7  8  8  8  8  8  7  6  5  4  3  2  1  0
         0  1  2  3  4  5  6  7  8  9  9  9  8  7  6  5  4  3  2  1  0
         0  1  2  3  4  5  6  7  8  9 10  9  8  7  6  5  4  3  2  1  0
         0  1  2  3  4  5  6  7  8  9  9  9  8  7  6  5  4  3  2  1  0
         0  1  2  3  4  5  6  7  8  8  8  8  8  7  6  5  4  3  2  1  0
         0  1  2  3  4  5  6  7  7  7  7  7  7  7  6  5  4  3  2  1  0
         0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
         0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
         0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
         0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
         0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
         0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
         0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0


 the minimum number of cells after, before, above, and below a  10x10  square matrix
──────────────────────────────────────────────────────────────────────────────────────
                                 0 0 0 0 0 0 0 0 0 0
                                 0 1 1 1 1 1 1 1 1 0
                                 0 1 2 2 2 2 2 2 1 0
                                 0 1 2 3 3 3 3 2 1 0
                                 0 1 2 3 4 4 3 2 1 0
                                 0 1 2 3 4 4 3 2 1 0
                                 0 1 2 3 3 3 3 2 1 0
                                 0 1 2 2 2 2 2 2 1 0
                                 0 1 1 1 1 1 1 1 1 0
                                 0 0 0 0 0 0 0 0 0 0


  the minimum number of cells after, before, above, and below a  9x9  square matrix
──────────────────────────────────────────────────────────────────────────────────────
                                  0 0 0 0 0 0 0 0 0
                                  0 1 1 1 1 1 1 1 0
                                  0 1 2 2 2 2 2 1 0
                                  0 1 2 3 3 3 2 1 0
                                  0 1 2 3 4 3 2 1 0
                                  0 1 2 3 3 3 2 1 0
                                  0 1 2 2 2 2 2 1 0
                                  0 1 1 1 1 1 1 1 0
                                  0 0 0 0 0 0 0 0 0


  the minimum number of cells after, before, above, and below a  2x2  square matrix
──────────────────────────────────────────────────────────────────────────────────────
                                         0 0
                                         0 0


  the minimum number of cells after, before, above, and below a  1x1  square matrix
──────────────────────────────────────────────────────────────────────────────────────
                                          0

Ring

see "working..." + nl
see "Minimum number of cells after, before, above and below NxN squares:" + nl
row = 0
cellsMin = []

for n = 1 to 10
    for m = 1 to 10
        cells = []
        add(cells,m-1)
        add(cells,10-m)
        add(cells,n-1)
        add(cells,10-n)
        min = min(cells)
        add(cellsMin,min)
    next
next

ind = 100
for n = 1 to ind
    row++
    see "" + cellsMin[n] + " "
    if row%10 = 0
       see nl
    ok
next  

see "done..." + nl
Output:
working...
Minimum number of cells after, before, above and below NxN squares:
0 0 0 0 0 0 0 0 0 0 
0 1 1 1 1 1 1 1 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 1 1 1 1 1 1 1 0 
0 0 0 0 0 0 0 0 0 0 
done...

Ruby

def dist2edge(n)
  width = (n/2).to_s.size+1
  m = n-1
  (0..m).map do |x|
    (0..m).map{|y| [x, y, m-x, m-y].min.to_s.center(width) }.join
  end
end
    
puts dist2edge(10)
Output:
0 0 0 0 0 0 0 0 0 0 
0 1 1 1 1 1 1 1 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 1 1 1 1 1 1 1 0 
0 0 0 0 0 0 0 0 0 0 

V (Vlang)

Translation of: Go
fn print_min_cells(n int) {
    println("Minimum number of cells after, before, above and below $n x $n square:")
    for r in 0..n {
        mut cells := []int{len: n}
        for c in 0..n {
            nums := [n - r - 1, r, c, n - c - 1]
            mut min := n
            for num in nums {
                if num < min {
                    min = num
                }
            }
            cells[c] = min
        }
        println(cells)
    }
}
 
fn main() {
    for n in [23, 10, 9, 2, 1] {
        print_min_cells(n)
        println('')
    }
}
Output:
Same as Go entry

Wren

Library: Wren-math
Library: Wren-fmt
import "./math" for Nums
import "./fmt" for Fmt

var printMinCells = Fn.new { |n|
    System.print("Minimum number of cells after, before, above and below %(n) x %(n) square:")
    var p = (n < 21) ? 1 : 2
    for (r in 0...n) {
        var cells = List.filled(n, 0)
        for (c in 0...n) cells[c] = Nums.min([n-r-1, r, c, n-c-1])
        Fmt.print("$*d", p, cells)
    }
}

for (n in [23, 10, 9, 2, 1]) {
    printMinCells.call(n)
    System.print()
}
Output:
Minimum number of cells after, before, above and below 23 x 23 square:
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 11 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9 10 10 10  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  9  9  9  9  9  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  8  8  8  8  8  8  8  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  7  7  7  7  7  7  7  7  7  6  5  4  3  2  1  0
 0  1  2  3  4  5  6  6  6  6  6  6  6  6  6  6  6  5  4  3  2  1  0
 0  1  2  3  4  5  5  5  5  5  5  5  5  5  5  5  5  5  4  3  2  1  0
 0  1  2  3  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  3  2  1  0
 0  1  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  2  1  0
 0  1  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  1  0
 0  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

Minimum number of cells after, before, above and below 10 x 10 square:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 9 x 9 square:
0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 2 x 2 square:
0 0
0 0

Minimum number of cells after, before, above and below 1 x 1 square:
0

XPL0

func Min(A, B);
int  A, B;
return if A<B then A else B;

def N=10, M=N-1, C=M/2;
int X, Y, VX, VY;
[for Y:= 0 to M do
    [for X:= 0 to M do
        [VX:= if X <= C then X else M-X;
         VY:= if Y <= C then Y else M-Y;
         IntOut(0, Min(VX, VY));  ChOut(0, ^ );
        ];
    CrLf(0);
    ];
]
Output:
0 0 0 0 0 0 0 0 0 0 
0 1 1 1 1 1 1 1 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 1 1 1 1 1 1 1 0 
0 0 0 0 0 0 0 0 0 0