Run results for: Array rotate juggling

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:73.0) Gecko/20100101 Firefox/73.0

Browser: Firefox 73

Operating system: Mac OS X 10.14

Device Platform: Desktop

Date tested: 4 years ago

Test name	Executions per second
Recursive Small	168868.3 Ops/sec
Recursive Medium	84.9 Ops/sec
Recursive Long	0.0 Ops/sec
Direct Small	473217.6 Ops/sec
Direct Medium	46451.0 Ops/sec
Direct Long	557.0 Ops/sec
Juggling small	1488881.0 Ops/sec
Juggling medium	339478.8 Ops/sec
Juggling large	1208.2 Ops/sec

Script Preparation code:

var arraySmall = new Array(12).map((v,i)=>i);
var arrayMedium = new Array(1200).map((v,i)=>i);
var arrayLong = new Array(120000).map((v,i)=>i);

Tests:

Recursive Small
const rotateArrayRecursive = (numberRotations, array) => { const n = Math.abs(numberRotations); if (n === 0) { return [...array]; } else if (n === 1) { return [array[array.length], ...array.slice(0,array.length-1) ]; } else { return rotateArrayRecursive(1, rotateArrayRecursive(n - 1, array)); } } rotateArrayRecursive(4,arraySmall);
Recursive Medium
const rotateArrayRecursive = (numberRotations, array) => { const n = Math.abs(numberRotations); if (n === 0) { return [...array]; } else if (n === 1) { return [array[array.length], ...array.slice(0,array.length-1) ]; } else { return rotateArrayRecursive(1, rotateArrayRecursive(n - 1, array)); } } rotateArrayRecursive(456,arrayMedium);
Recursive Long
const rotateArrayRecursive = (numberRotations, array) => { const n = Math.abs(numberRotations); if (n === 0) { return [...array]; } else if (n === 1) { return [array[array.length], ...array.slice(0,array.length-1) ]; } else { return rotateArrayRecursive(1, rotateArrayRecursive(n - 1, array)); } } rotateArrayRecursive(45678,arrayLong);
Direct Small
const rotateArrayDirect = (desiredRotation, array) => { // Size of the array, needed later on const arrayLength = array.length; // Ensure we rotate by the right amount, whatever the desiredRotation value // This formula is needed because JS % modulo operator returns negative output for negative inputs const effectiveRotation = ((desiredRotation % arrayLength) + 2 * arrayLength) % arrayLength; // Cut the array in two parts and merge them return [ ...array.slice(effectiveRotation, arrayLength), ...array.slice(0, effectiveRotation) ]; } rotateArrayDirect(4,arraySmall);
Direct Medium
const rotateArrayDirect = (desiredRotation, array) => { // Size of the array, needed later on const arrayLength = array.length; // Ensure we rotate by the right amount, whatever the desiredRotation value // This formula is needed because JS % modulo operator returns negative output for negative inputs const effectiveRotation = ((desiredRotation % arrayLength) + 2 * arrayLength) % arrayLength; // Cut the array in two parts and merge them return [ ...array.slice(effectiveRotation, arrayLength), ...array.slice(0, effectiveRotation) ]; } rotateArrayDirect(456,arrayMedium);
Direct Long
const rotateArrayDirect = (desiredRotation, array) => { // Size of the array, needed later on const arrayLength = array.length; // Ensure we rotate by the right amount, whatever the desiredRotation value // This formula is needed because JS % modulo operator returns negative output for negative inputs const effectiveRotation = ((desiredRotation % arrayLength) + 2 * arrayLength) % arrayLength; // Cut the array in two parts and merge them return [ ...array.slice(effectiveRotation, arrayLength), ...array.slice(0, effectiveRotation) ]; } rotateArrayDirect(45678,arrayLong);
Juggling small
const gcd = (a, b) => { if(b==0){ return a; }else{ return gcd(b, a%b); } } const rotateArrayJuggling = (desiredRotation, array) => { const n = array.length; let temp = null; let j = null; let k = null; const gcdResult = gcd(desiredRotation, n); for (let i = 0; i < gcdResult; i++){ temp = array[i]; j = i; while (true){ k = j + desiredRotation; if (k >= n){ k = k - n; } if (k== i){ break; } array[j] = array[k]; j = k; } array[j] = temp; } return array; } rotateArrayJuggling(4,arraySmall);
Juggling medium
const gcd = (a, b) => { if(b==0){ return a; }else{ return gcd(b, a%b); } } const rotateArrayJuggling = (desiredRotation, array) => { const n = array.length; let temp = null; let j = null; let k = null; const gcdResult = gcd(desiredRotation, n); for (let i = 0; i < gcdResult; i++){ temp = array[i]; j = i; while (true){ k = j + desiredRotation; if (k >= n){ k = k - n; } if (k== i){ break; } array[j] = array[k]; j = k; } array[j] = temp; } return array; } rotateArrayJuggling(456,arrayMedium);
Juggling large
const gcd = (a, b) => { if(b==0){ return a; }else{ return gcd(b, a%b); } } const rotateArrayJuggling = (desiredRotation, array) => { const n = array.length; let temp = null; let j = null; let k = null; const gcdResult = gcd(desiredRotation, n); for (let i = 0; i < gcdResult; i++){ temp = array[i]; j = i; while (true){ k = j + desiredRotation; if (k >= n){ k = k - n; } if (k== i){ break; } array[j] = array[k]; j = k; } array[j] = temp; } return array; } rotateArrayJuggling(45678,arrayLong);

Run results for: Array rotate juggling

Two implementations of array rotatee

Recursive Small

Recursive Medium

Recursive Long

Direct Small

Direct Medium

Direct Long

Juggling small

Juggling medium

Juggling large