### Question :

I have an array:

```
A = np.array([0, 0, 0])
```

and list of indices with repetitions:

```
idx = [0, 0, 1, 1, 2, 2]
```

and another array i would like to add to A using indices above:

```
B = np.array([1, 1, 1, 1, 1, 1])
```

The operation:

```
A[idx] += B
```

Gives the result: `array([1, 1, 1])`

, so obviously values from `B`

were not summed up. What is the best way to get as a result `array([2, 2, 2])`

? Do I have to iterate over indices?

##
Answer #1:

for this numpy 1.8 added the `at`

reduction:

at(a, indices, b=None)

Performs unbuffered in place operation on operand ‘a’ for elements

specified by ‘indices’. For addition ufunc, this method is equivalent

to`a[indices] += b`

, except that results are accumulated for elements

that are indexed more than once. For example,`a[[0,0]] += 1`

will

only increment the first element once because of buffering, whereas

`add.at(a, [0,0], 1)`

will increment the first element twice... versionadded:: 1.8.0

```
In [1]: A = np.array([0, 0, 0])
In [2]: B = np.array([1, 1, 1, 1, 1, 1])
In [3]: idx = [0, 0, 1, 1, 2, 2]
In [4]: np.add.at(A, idx, B)
In [5]: A
Out[5]: array([2, 2, 2])
```

##
Answer #2:

How about:

```
A = np.array([1, 2, 3])
idx = [0, 0, 1, 1, 2, 2]
A += np.bincount(idx, minlength=len(A))
```

Obviously it’s even more simple if A starts off as zeros:

```
A = np.bincount(idx)
```