# [R], <s>62</s> 58 bytes

<!-- language-all: lang-r -->

    function(a,l)diag(diffinv(matrix(a,max(a)*l+1,l))[a+2,])-a

[Try it online!][TIO-jikiej7w]

[R]: https://www.r-project.org/
[TIO-jikiej7w]: https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNRJ0czJTMxXSMlMy0tM69MIzexpCizAiiemwgkNbVytA2BSjSjE7WNdGI1dRP/p2kkaxjrGOkY6lhq6pho/gcA "R – Try It Online"

An alternative to the [other R solution](https://codegolf.stackexchange.com/a/166945/67312). In the comments [JayCe made a mention of `cumsum`](https://codegolf.stackexchange.com/questions/166920/replace-me-by-the-sum-of-my-cyclic-successors/166929#comment403701_166945) which triggered something in my brain to use `diffinv` and matrix recycling instead of `rep`.

### Explanation:

Given input array `a`, let `M=max(a)` and `l=length(a)`.

Observe that `M+l` is the maximum possible index we'd need to access, and that `M+l<=M*l+1`, since if `M,l>1`,`M+l<=M*l` (with equality only when `M=l=2`) and if `l==1` or `M==1`, then `M+l==M*l+1`.

By way of example, let `a=c(4,3,2,1)`. Then `M=l=4`.

We construct the `M*l+1 x l` matrix in R by `matrix(a,max(a)*l+1,l)`. Because R recycles `a` in column-major order, we end up with a matrix repeating the elements of `a` as such:

<pre><code>      [,1] [,2] [,3] [,4]
 [1,]    4    3    2    1
 [2,]    3    2    1    4
 [3,]    2    1    4    3
 [4,]    1    4    3    2
 [5,]    4    3    2    1
 [6,]    3    2    1    4
 [7,]    2    1    4    3
 [8,]    1    4    3    2
 [9,]    4    3    2    1
[10,]    3    2    1    4
[11,]    2    1    4    3
[12,]    1    4    3    2
[13,]    4    3    2    1
[14,]    3    2    1    4
[15,]    2    1    4    3
[16,]    1    4    3    2
[17,]    4    3    2    1

</code></pre>

Each column is the cyclic successors of each element of `a`, with `a` across the first row; this is due to the way that R recycles its arguments in a matrix.

Next, we take the inverse "derivative" with `diffinv`, essentially the cumulative sum of each column with an additional `0` as the first row, generating the matrix

<pre><code>      [,1] [,2] [,3] [,4]
 [1,]    0    0    0    0
 [2,]    4    3    2    1
 [3,]    7    5    3    5
 [4,]    9    6    7    8
 [5,]   10   10   10   10
 [6,]   14   13   12   11
 [7,]   17   15   13   15
 [8,]   19   16   17   18
 [9,]   20   20   20   20
[10,]   24   23   22   21
[11,]   27   25   23   25
[12,]   29   26   27   28
[13,]   30   30   30   30
[14,]   34   33   32   31
[15,]   37   35   33   35
[16,]   39   36   37   38
[17,]   40   40   40   40
[18,]   44   43   42   41
</code></pre>

In the first column, entry `6=4+2` is equal to `14=4 + (3+2+1+4)`, which is the cyclic successor sum (CSS) plus a leading `4`. Similarly, in the second column, entry `5=3+2` is equal to `10=3 + (4+1+2)`, and so forth.

So in column `i`, the `a[i]+2`nd entry is equal to `CSS(i)+a[i]`. Hence, we take rows indexed by `a+2`, yielding a square matrix:

<pre><code>     [,1] [,2] [,3] [,4]
[1,]   14   13   12   11
[2,]   10   10   10   10
[3,]    9    6    7    8
[4,]    7    5    3    5
</code></pre>

The entries along the diagonal are equal to the cyclic successor sums plus `a`, so we extract the diagonal and subtract `a`, returning the result as the cyclic successor sums.