Assign sequential count for numerical runs

Question

I'd like to assign a cumulative numerical value for sequential runs in a binary vector. What I have is

x = [0 0 0 1 1 0 1 1 1 0 1 0 0 0 0 0 0],

and what I would like is

y = [1 2 3 1 2 1 1 2 3 1 1 1 2 3 4 5 6].

The solution using sum/cumsum/unique/find range of functions alludes me. Any help would be greatly appreciated.

Wirer

Answer 1

Here's a way:

a = arrayfun(@(x)(1:x), diff(find([1,diff(x),1])), 'uni', 0);
[a{:}]

The idea is to generate a list of the 'run lengths', i.e. [3,2,1,3,1,1,6] in your case, then just concatenate a bunch of vectors that count to each value in that list, i.e. cat(2, 1:3, 1:2, 1:1, 1:3.... I use arrayfun as a shortcut for reapplying the : operator and then use the comma separated list that {:} returns as a shortcut for the concatenation.

Adsorbent

Well spotted on applying @(x) 1:x on runlength encoding! – Dehumanize

wow. great! Your one liners are so cool (and complex) sometimes they give me a headache! Nice job. – Grecoroman

Though (at least for me personally) a = arrayfun(@(x) (1:x), diff(find([true, diff(x) ~= 0, true])), 'uni', 0) would be slightly more readable. – Dehumanize

@Dehumanize agreed - but I think Bentoy's answer is better anyways – Adsorbent

@Adsorbent - nice solution. I wouldn't have considered using arrayfun. Thank you. – Wirer

@Wirer Thanks but I think you should consider the diff/cumsum approach. I don't know what your goals are and I haven't benched marked but I would suspect that it is faster and in my opinion it is clearer as well – Adsorbent

I've borrowed this answer here (with due credit) – Consent

Answer 2

(Not a one-liner, alas ...):

F = find(diff(x))+1;
y = ones(size(x));
y(F) = y(F)-diff([1,F]);
y = cumsum(y);

First, find all positions in x where there is a change; then build a vector of 1 where you substract the length of each continuous segment. At the end, take the cumsum of it.

Amagasaki

This is a clever approach! – Adsorbent

I also had the usual suspects find, diff and especially cumsum in my mind when reading the question. This would look pretty similar to my (yet non-existent) approach. – Dehumanize

This is the type of solution I originally had in mind - but couldn't quite get working. Many thanks @Bentoy13. – Wirer

Answer 3

Create a sparse matrix such that each run is on a different column, and then do the cumulative sum:

t = sparse(1:numel(x), cumsum([1 diff(x)~=0]), 1);
y = nonzeros(cumsum(t).*t).';

---

Use accumarray with a custom function to generate each increasing pattern in a different cell, and then concatenate all cells:

y = accumarray(cumsum([1 diff(x)~=0]).', 1, [], @(x) {1:numel(x).'});
y = [y{:}];

Consent

an alternative solution I would have never considered. – Wirer