Find centralized, trusted content and collaborate around the technologies you use most.
Learn more about CollectivesStack Internal
Knowledge at work
Bring the best of human thought and AI automation together at your work.
Explore Stack Internal
I'd use Daniel's approachDaniel's approach. But just to provide an alternative:
m = 4; %// size of each initial "block" [~, ind] = sort(mod(0:numel(u)-1,m)+1); uNew = u(ind); Note that this works because, as per sort's documentation,
The ordering of the elements in B (output) preserves the order of any equal elements in A (input)
I'd use Daniel's approach. But just to provide an alternative:
m = 4; %// size of each initial "block" [~, ind] = sort(mod(0:numel(u)-1,m)+1); uNew = u(ind); Note that this works because, as per sort's documentation,
The ordering of the elements in B (output) preserves the order of any equal elements in A (input)
I'd use Daniel's approach. But just to provide an alternative:
m = 4; %// size of each initial "block" [~, ind] = sort(mod(0:numel(u)-1,m)+1); uNew = u(ind); Note that this works because, as per sort's documentation,
The ordering of the elements in B (output) preserves the order of any equal elements in A (input)
I'd use Daniel's approach. But since you wantjust to provide an alternative, here's one:
m = 4; %// size of each initial "block" [~, ind] = sort(mod(0:numel(u)-1,m)+1); uNew = u(ind); Note that this works because, as per sort's documentation,
The ordering of the elements in B (output) preserves the order of any equal elements in A (input)
I'd use Daniel's approach. But since you want an alternative, here's one:
m = 4; %// size of each initial "block" [~, ind] = sort(mod(0:numel(u)-1,m)+1); uNew = u(ind); Note that this works because, as per sort's documentation,
The ordering of the elements in B (output) preserves the order of any equal elements in A (input)
I'd use Daniel's approach. But just to provide an alternative:
m = 4; %// size of each initial "block" [~, ind] = sort(mod(0:numel(u)-1,m)+1); uNew = u(ind); Note that this works because, as per sort's documentation,
The ordering of the elements in B (output) preserves the order of any equal elements in A (input)
I'd use Daniel's approach. But since you want an alternative, here's one:
m = 4; %// size of each initial "block" [~, ind] = sort(mod(0:numel(u)-1,m)+1); uNew = u(ind); Note that this works because, as per sort's documentation,
The ordering of the elements in B (output) preserves the order of any equal elements in A (input)
I'd use Daniel's approach. But since you want an alternative, here's one:
m = 4; %// size of each initial "block" [~, ind] = sort(mod(0:numel(u)-1,m)+1); uNew = u(ind); I'd use Daniel's approach. But since you want an alternative, here's one:
m = 4; %// size of each initial "block" [~, ind] = sort(mod(0:numel(u)-1,m)+1); uNew = u(ind); Note that this works because, as per sort's documentation,
The ordering of the elements in B (output) preserves the order of any equal elements in A (input)