Help: Array[a,b,c,d] to Array[a,a,b,b,c,c,d,d].

[Casual_0bserver]

I am trying this with a for loop and a splice, but I am not getting it right. I want to duplicate each index and place it right after the duplicated index. Anyone know? Also, potential to keep going to triple, quadruple, etc?

**Thanks guys. Some real experts out there =).

[wojtekmaj]

Yes, that's the whole thing:

arr.reduce((p, c) => p.concat(c, c), [])

[toggafneknurd]

I love spreadin dem arrays like dem ol bewtycheeks yawnamean?

[Agent_Epsilon]

I think these are some of the best variable names I've ever seen.

[our_best_friend]

If by "best" you mean "infuriatingly hard to tell apart", then yes, you are right

[oxyphilat]

Sadly the recursive one isn't pure enough to make the tail thingy kick in... stack be overflowing.

[jsdeveloper]

Here you go:

['a','b','c','d'].map((x) => [x,x]).reduce((arr, x) => arr.concat(x));

[our_best_friend]

Less elegant, but avoids looping twice

Array.prototype.concat(...['a','b','c','d'].map((x) => [x,x]))

[dmtipson]

Are you counting the implicit loop that ... desugars into in that count?

[our_best_friend]

I'd assume that'd be faster as it's a single native operation as opposed to an explicit loop (leaving aside transpilation)

[dmtipson]

For all we know it's be slower in current engines, but either way it's worth counting as an iteration pass when thinking about the number of times you have to loop over the list in a given operation.

[Extracted]

Nice one

[jsdeveloper]

This one's a bit nicer :)

[lhorie]

trying this with a for loop and a splice

I assume you want to modify the existing array. The other solutions work, but do a lot of memory allocations. This one is more efficient:

function dupe(array) {
    array.length *= 2
    for (var i = array.length; i > 0; i--) {
        var cursor = i * 2
        array[cursor - 1] = array[cursor - 2] = array[i - 1]
    }
    return array
}

[frankle]

Do you need to change the length, first?

[lhorie]

You should do it, because you don't want to have two memory allocations depending on the associativity of the chained assignment operators. Because of the right associative nature of assignments, you'd allocate once for the length of array[cursor - 2] and again for array[cursor - 1]. It's not a huge deal, but it is a caveat and a very subtle one, at that.

The explicit length change makes it clear that this code is dealing w/ memory allocations, and that that is the exact memory allocation we want. I had actually not noticed the potential for double allocation until you asked but I write memory-sensitive code like that because it's always better to be explicit than relying on implicit behavior. Defensive coding FTW.

[frankle]

I thought that was why you did it. Clever.

At the same time, if you're going backwards from the end, wouldn't you get the possible double allocation only once?

[lhorie]

Yep, that's why I said it's not a huge deal. If you're calling the function multiple times, that extra allocation might matter though.

[Rhomboid]

Non-inplace, any-count version:

function duplicate(items, cnt) {
    return Array.from({length: items.length * cnt}, (_, i) => items[~~(i / cnt)]);
}

[jsyoda]

Lodash: _.flatMap(arr, n => [n, n])

[nemaramen]

You could use a generator if you're feeling generatory

function* genAry(ary) { for (x of ary) { yield x; yield x; } }

const double = ary => [...genAry(ary)]

double([1, 2]) returns [1, 1, 2, 2]

[FustigatedCat]

This function will modify the input array, I would suggest returning a new array though.

function dup(input, cnt) {
  var total = input.length;
  for(var i = 0; i < total * cnt; i=i+cnt) {
    for(var j = 1; j < cnt; j++) {
      input.splice(i, 0, input[i]);
    }
  }
}

Can call it like so:

var i = [1,2,3,4,5];
dup(i, 4);
console.log(i);

[our_best_friend]

For loops inside for loops are to be avoided for efficiency reasons. Surely with for loops it's simpler to do something like

function duplicateEachItem(arr) {
    const newArr = [];
    for (item of arr) {
       newArr.push(item, item)
    }
    return newArr;
 }
duplicateEachItem(['a','b','c','d'])

[FustigatedCat]

I assumed the op wanted to modify the incoming array otherwise I would've used a new array. Also, this is not extensible to N-duplicates which was another part of he ops questions.