Suppose you have either two arrays:

```
index = [1, 2, 3]
counts = [2, 3, 2]
```

or a singular array

```
arr = [1, 1, 2, 2, 2, 3, 3]
```

How can I efficiently construct the matrix

```
[
[1, 1, 0, 0, 0, 0, 0],
[1, 1, 0, 0, 0, 0, 0],
[0, 0, 2, 2, 2, 0, 0],
[0, 0, 2, 2, 2, 0, 0],
[0, 0, 2, 2, 2, 0, 0],
[0, 0, 0, 0, 0, 3, 3],
[0, 0, 0, 0, 0, 3, 3]
]
```

with NumPy?

I know that

```
square = np.zeros((7, 7))
np.fill_diagnol(square, arr) # see arr above
```

produces

```
[
[1, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0],
[0, 0, 2, 0, 0, 0, 0],
[0, 0, 0, 2, 0, 0, 0],
[0, 0, 0, 0, 2, 0, 0],
[0, 0, 0, 0, 0, 3, 0],
[0, 0, 0, 0, 0, 0, 3]
]
```

How do I "expand" the diagonal by `n`

where `n`

is `counts[index-1]`

for the values specified by `index[I]`

```
tmp = np.array((arr * N)).reshape((len(arr), len(arr))
np.floor( (tmp + tmp.T) / 2 ) # <-- this is closer
array([[1., 1., 1., 1., 1., 2., 2.],
[1., 1., 1., 1., 1., 2., 2.],
[1., 1., 2., 2., 2., 2., 2.],
[1., 1., 2., 2., 2., 2., 2.],
[1., 1., 2., 2., 2., 2., 2.],
[2., 2., 2., 2., 2., 3., 3.],
[2., 2., 2., 2., 2., 3., 3.]])
```

This gets what I want, but probably doesn't scale that well?

```
riffled = list(zip(index, counts))
riffled
# [(1, 2), (2, 3), (3, 2)]
```

```
a = np.zeros((len(arr), len(arr))) # 7, 7 square
last = 0 # <-- keep track of current sub square
for i, c in riffled:
a[last:last+c, last:last+c] = np.ones((c, c)) * i
last += c # <-- shift square
```

yield

```
array([[1., 1., 0., 0., 0., 0., 0.],
[1., 1., 0., 0., 0., 0., 0.],
[0., 0., 2., 2., 2., 0., 0.],
[0., 0., 2., 2., 2., 0., 0.],
[0., 0., 2., 2., 2., 0., 0.],
[0., 0., 0., 0., 0., 3., 3.],
[0., 0., 0., 0., 0., 3., 3.]])
```

`np.equal.outer(arr, arr) * arr`