Create a matrix where values are 1 one the outer most rows/cols and increase towards the center

As the title says, I want to create a matrix where values are 1 one the outer most rows/cols and increase towards the center.

Here is as far as I have gotten:

dims = (5,5)
m1 = zeros(Int, dims)

for i in 1:dims[1], j in 1:dims[2]
    m1[i,j] = (min(i,j))
end

5×5 Matrix{Int64}:
 1  1  1  1  1
 1  2  2  2  2
 1  2  3  3  3
 1  2  3  4  4
 1  2  3  4  5

I then tried using various upper and lower triangle functions to copy/paste parts of the triangle but no joy. What I want:

5×5 Matrix{Int64}:
     1  1  1  1  1
     1  2  2  2  1
     1  2  3  2  1
     1  2  2  2  1
     1  2  1  1  1

Any advice would be much appreciated.

Here is another answer:, which also provides an example for using a function I've suggested in https://stackoverflow.com/questions/76191746/is-there-a-simple-way-to-enumerate-indices-of-an-array-in-base

julia> indices(A) = Iterators.map(Tuple, CartesianIndices(A))

julia> dims = (5,5)

julia> [min(minimum.(zip(I,dims.-I.+1))...) for I in indices(dims)]
5×5 Matrix{Int64}:
 1  1  1  1  1
 1  2  2  2  1
 1  2  3  2  1
 1  2  2  2  1
 1  1  1  1  1

julia> dims = (4,4,3)
(4, 4, 3)

julia> [min(minimum.(zip(I,dims.-I.+1))...) for I in indices(dims)]
4×4×3 Array{Int64, 3}:
[:, :, 1] =
 1  1  1  1
 1  1  1  1
 1  1  1  1
 1  1  1  1

[:, :, 2] =
 1  1  1  1
 1  2  2  1
 1  2  2  1
 1  1  1  1

[:, :, 3] =
 1  1  1  1
 1  1  1  1
 1  1  1  1
 1  1  1  1

As shown, this method generalizes to higher dimensional arrays naturally, and it will work with non-square arrays too.

DNF managed to get rid of some slowing allocations (see his answer), and so:

[min(t..., (dims .+ 1 .- t)...) for t in indices(dims)]

is a simple rewrite of his code using the indices shortcut.

Here's a simple solution using a conditional to tell if you're past the diagonal and behave accordingly:

for i in 1:dims[1], j in 1:dims[2]
    if  (i + j) < dims[1] + 1
      m1[i,j] = (min(i,j))
    else
      m1[i,j] = min(dims[1] - i + 1, dims[2] - j + 1)
    end
end

Here's a simple one-liner, that is also very fast:

foo(N) = [min(i, j, N+1-i, N+1-j) for i in 1:N, j in 1:N]

For more generality, and almost as good performance, try

bar(dims...) = [(t=Tuple(i); min(t..., (dims .+ 1 .- t)...)) for i in CartesianIndices(dims)]

It is quite similar to @DanGetz's solution, but avoids zip, and uses Tuple instead, which seems advantageous for performance.