Run results for: Array rotate juggling

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	1488880.9 Ops/sec
Juggling medium	339478.8 Ops/sec
Juggling large	1208.2 Ops/sec

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