I want to achieve this
var arr = [1,2,3];
var duplicateArr = duplicate(arr, 2) // will be [1,2,3,1,2,3]
var duplicateArr2 = duplicate(arr, 3) // will be [1,2,3,1,2,3,1,2,3]
I have implemented it like this:
function duplicate(arr, n) {
var len = arr.length;
if (n == 0 || n == 1) {
return arr;
}
if (n > 1) {
for (var j = 0; j < n - 1; j++) {
for (var i = 0; i < len; i++) {
arr.push(arr[i])
}
}
}
console.log(arr);
}
duplicate([1, 2, 3], 3);
I know this may not be the efficient way to do it.
3 Answers 3
The special treatment for n == 0
and n == 1
, and the n > 1
condition are unnecessary. The outer loop condition already handles these cases,
so this is roughly equivalent:
function duplicate(arr, n) {
var len = arr.length;
for (var j = 1; j < n; j++) {
for (var i = 0; i < len; i++) {
arr.push(arr[i]);
}
}
return arr;
}
I say "roughly", because I dropped the console.log
.
You can avoid the nested for loops by adding the entire array at the same time. (I'm also using Janos' suggestion here)
function duplicate(arr, n) {
let result = [];
for(let i=0; i<n; i++) {
result.push(...arr);
}
return(result);
}
We need the original array unmodified, so we can keep adding it, so I'm using a new result array. This has a few benefits. Firstly it's more common to leave the input array unmodified and return a new array, and secondly it returns an empty array when n=0
, which I think makes more sense.
This uses the ES6 spread syntax. If you don't want to use ES6 you can replace
result.push(...arr);
with
result = result.concat(arr);
I think, this will reduce one loop
function duplicate(arr, n) {
var len = arr.length;
if (n == 0 || n == 1) {
return arr;
}
if (n > 1) {
for (var j = 0; j < n - 1; j++) {
arr = arr.concat(arr); //**changed here**
}
}
console.log(arr);;
}
-
1\$\begingroup\$ We generally like to see more explanation in our reviews. How does this work? Also, have you tested it? Instead of concatenating the original array, it doubles the array. It will grow exponentially rather than linearly. \$\endgroup\$mdfst13– mdfst132016年09月30日 08:45:44 +00:00Commented Sep 30, 2016 at 8:45
-
1\$\begingroup\$ Doing concat many times is much slower because it makes progressively growing copies of the intermediate array. In case of large n this code will eat lots of memory too. And your code is simply wrong, it doubles the array in each iteration thus instead of n copies, there will be 2^n \$\endgroup\$woxxom– woxxom2016年09月30日 09:11:02 +00:00Commented Sep 30, 2016 at 9:11
repeatArray
. \$\endgroup\$