Как создать функцию Diamond с помощью массивов

Question

Мне нужно создать функцию, которая дает форму ромба при заданной длине стороны. алмаз должен состоять из массивов 0 и 1

Пока что я понял, как сделать бриллиант, я не знаю, как запрограммировать функцию для разной длины стороны

Пока у меня есть: для длины стороны 3

import numpy as np

#line1
a=np.zeros(3+2)
a[3-1]=1

#line2
b=np.zeros(3+2)
b[3-2]=1
b[3]=1

#line3
c=np.zeros(3+2)
c[3-3]=1
c[3+1]=1

print(np.concatenate((a,b,c,b,a),axis=1).reshape(5,5))

как я могу написать функцию для разной длины также, если дана длина 1, он должен вернуть [[1]]

Любые отзывы будут оценены

обновление: я думаю, что цикл может работать, чтобы выяснить количество строк

Answer 1

Вы можете сделать это, используя пересечение горизонтальных и вертикальных шаблонов:

import numpy as np

N       = 5
H       = abs(np.arange(1-N,N+1,2))//2
V       = (N-1)//2-H[:,None]
diamond = (H==V)*1

print(diamond)

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

Визуально это соответствует пересечению числовых равенств между строками и столбцами:

для N = 7:

     [3, 2, 1, 0, 1, 2, 3]
   0  .  .  .  x  .  .  .         
   1  .  .  x  .  x  .  .
   2  .  x  .  .  .  x  .     
   3  x  .  .  .  .  .  x
   2  .  x  .  .  .  x  .
   1  .  .  x  .  x  .  .
   0  .  .  .  x  .  .  .

для N = 8:

     [3, 2, 1, 0, 0, 1, 2, 3]
   0  .  .  .  x  x  .  .  .         
   1  .  .  x  .  .  x  .  .         
   2  .  x  .  .  .  .  x  .         
   3  x  .  .  .  .  .  .  x         
   3  x  .  .  .  .  .  .  x         
   2  .  x  .  .  .  .  x  .         
   1  .  .  x  .  .  x  .  .         
   0  .  .  .  x  x  .  .  .         

Если вы хотите, чтобы алмаз был заполнен, используйте diamond = (H<=V)*1

Answer 2

Я выбрал более длинный путь, чтобы расширить функцию для обработки других геометрий

import numpy as np

def diamondarray(dimension=1):

    #// initialize 2d array
    a=np.zeros((dimension,dimension))

    #// find the middle of the array
    midpoint=(dimension-1)/2

    #// initialize an offset
    offset=-1
    offsetstep=1

    #// loop through rows and columns
    for row in range(dimension):
        if dimension%2 == 0 and row == np.ceil(midpoint):
            #// repeat offset for second midpoint row
            offset=offset
        else:
            if row <= np.ceil(midpoint):
                #// increase offset for each row for top
                offset=offset+offsetstep
            else:
                #// decrease offset for each row for bottom
                offset=offset-offsetstep

        for col in range(dimension):
            #// set value to one
            if dimension%2 == 0:
                if col <= np.floor(midpoint):
                    if col == np.floor(midpoint)-offset:
                        a[row,col]=fill
                if col >= np.ceil(midpoint):
                    if col == int(midpoint)+offset+1:
                        a[row,col]=fill
            else:
                if col == midpoint+offset or col == midpoint-offset:
                    pass
                    a[row,col]=fill
    return a

Для N = 5:

печать (diamondarray (5))

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

Для N = 8:

печать (diamondarray (8))

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