交换除第一个和最后一个数组之外的所有数组元素

Question

I have an array that looks like this

const x = ['A','B','C','D','E']

I want to have an elegant function that would shuffle the content of the array but keeps the first or the last element fixed. Something like customShuffle(x) which will shuffle the array but ensures that the element "A" will be in the first position and the element "E" will be at the last position. All other elements are shuffled.

Answer 1

Using the shuffle algorithm from How to randomize (shuffle) a JavaScript array?

You can extend it like this:

function shuffle(array) {
  var currentIndex = array.length, temporaryValue, randomIndex;

  // While there remain elements to shuffle...
  while (0 !== currentIndex) {

    // Pick a remaining element...
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;

    // And swap it with the current element.
    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }

  return array;
}

function customShuffle(array, first, last) {
    if (first) {
      if (last) {
        const updatedArray = shuffle(array).filter(item => item !== first && item !== last);
        return [first, ...updatedArray, last];
      }

    const updatedArray = shuffle(array).filter(item => item !== first);
    return [first, ...updatedArray];
  }

  return shuffle(array);
}

Answer 2

If the first and last elements of the array always stay in that same place, you can apply a normal shuffling algorithm, like a modern variation of Fisher and Yates' , skipping those positions:

 function customShuffle(arr) { if (arr.length < 3) { return arr; } // Note the -2 (instead of -1) and the i > 1 (instead of i > 0): for (let i = arr.length - 2; i > 1; --i) { const j = 1 + Math.floor(Math.random() * i); [arr[i], arr[j]] = [arr[j], arr[i]]; } return arr; } console.log(customShuffle([1, 2, 3, 4, 5]).join(', ')); console.log(customShuffle(['A', 'B', 'C', 'D', 'E']).join(', ')); 

 .as-console-wrapper { max-height: 100vh; } 

Otherwise, if you want to choose the first and last elements, as you pointed out in your original question, you can do something like this:

1. Find the index of the elements you want to have in the first and last positions first: firstIndex and lastIndex .
2. If those elements exist (they might not be present), remove them from the array.
3. Apply a shuffling algorithm to the remaining elements (there's no need to also shuffle first and last ).
4. Add the first and last elements back into their place, if you need to.

 function customShuffle(arr, first, last) { // Find and remove first and last: const firstIndex = arr.indexOf(first); if (firstIndex !== -1) arr.splice(firstIndex, 1); const lastIndex = arr.indexOf(last); if (lastIndex !== -1) arr.splice(lastIndex, 1); // Normal shuffle with the remainign elements using ES6: for (let i = arr.length - 1; i > 0; --i) { const j = Math.floor(Math.random() * (i + 1)); [arr[i], arr[j]] = [arr[j], arr[i]]; } // Add them back in their new position: if (firstIndex !== -1) arr.unshift(first); if (lastIndex !== -1) arr.push(last); return arr; } console.log(customShuffle([1, 2, 3, 4, 5], 5, 1).join(', ')); console.log(customShuffle(['A', 'B', 'C', 'D', 'E'], 'E', 'C').join(', ')); console.log(customShuffle([1, 2, 3, 4, 5], 10, 20).join(', ')); 

 .as-console-wrapper { max-height: 100vh; } 

Answer 3

You can use this function which uses the modern version of the Fisher–Yates shuffle algorithm to shuffle the sub-array x.slice(1, x.length - 1) , which is x with the exclusion of the first and last elements, then adds them back to the shuffled sub-array:

 const x = ['A','B','C','D','E']; function customShuffle(x) { var y = x.slice(1, x.length - 1); var j, t, i; for (i = y.length - 1; i > 0; i--) { j = Math.floor(Math.random() * (i + 1)); t = y[i]; y[i] = y[j]; y[j] = t; } return [x[0]].concat(y).concat(x[x.length-1]); } console.log(customShuffle(x)); console.log(customShuffle(x)); console.log(customShuffle(x)); console.log(customShuffle(x)); 

Answer 4

You can do it like this. first and last params are optional.

Check if first is passed and if it is in the array. If so, then remove it from the array. Do the same for the last . Shuffle indices of the remaining array. Recreate new array based on the shuffled indices, as well as first and last arguments.

 const shuffle = (arr, first, last) => { let firstIn = false; let lastIn = false; if (first && arr.includes(first)) { arr.splice(arr.indexOf(first), 1); firstIn = true; } if (last && arr.includes(last)) { arr.splice(arr.indexOf(last), 1); lastIn = true; } const len = arr.length; const used = []; while (used.length !== len) { let r = Math.floor(Math.random() * len); if (!used.includes(r)) { used.push(r); } } const newArr = []; if (first && firstIn) { newArr.push(first); } for (let i = 0; i < len; i++) { newArr.push(arr[used[i]]); } if (last && lastIn) { newArr.push(last); } return newArr; } let arr = ['A', 'B', 'C', 'D', 'F']; arr = shuffle(arr); console.log(arr); arr = shuffle(arr, 'A'); console.log(arr); arr = shuffle(arr, 'A', 'B'); console.log(arr); 

shuffle(arr); will shuffle the whole array.
arr = shuffle(arr, 'A'); will move A to the front and shuffle the rest.
arr = shuffle(arr, 'A', 'B'); will move A to the front, B to the end, and shuffle the rest.

Word of caution: while this approach is not in-place, it will still mutate the original array, because of the splice method.

Answer 5

You could first generate new shuffled array and then check if first and last arguments are provided and take those elements and place them on first and last position.

 const x = ['A', 'B', 'C', 'D', 'E'] function shuffle(arr, first, last) { const newArr = arr.reduce((r, e, i) => { const pos = parseInt(Math.random() * (i + 1)) r.splice(pos, 0, e) return r; }, []); if (first) newArr.unshift(newArr.splice(newArr.indexOf(first), 1)[0]); if (last) newArr.push(newArr.splice(newArr.indexOf(last), 1)[0]) return newArr } console.log(shuffle(x)) console.log(shuffle(x, "A", "E")) 

Answer 6

Please try the following simple solution.This will shuffle all the elements other than the first and the last element of the array ( jsfiddle ):

 const x = ['A', 'B', 'C', 'D', 'E']; CustomShuffle(x); function CustomShuffle(x) { //shuffle the elements in between first and the last var max = x.length - 2; var min = 1; for (var i = max; i >= min; i--) { var randomIndex = Math.floor(Math.random() * (max - min + 1)) + min; var itemAtIndex = x[randomIndex]; x[randomIndex] = x[i]; x[i] = itemAtIndex; } alert(x); } 

In case first and last elements are not in place beforehand, you may try the following ( jsfiddle ):

const x = ['A', 'B', 'C', 'D', 'E'];
CustomShuffle(x, first = "B", last = "A");

function CustomShuffle(x, first, last) {

  //position first element correctly
  var indexToSwap = x.indexOf(first);
  if (indexToSwap != 0) {
    x = SwapValuesAtIndices(x, indexToSwap, 0);
  }

  //position last element correctly
  indexToSwap = x.indexOf(last);
  if (indexToSwap != x.length - 1) {
    x = SwapValuesAtIndices(x, indexToSwap, x.length - 1);
  }

  //randomly shuffle the remaining elements in between
  var max = x.length - 2;
  var min = 1;
  for (var i = max; i >= min; i--) {
    var randomIndex = Math.floor(Math.random() * (max - min + 1)) + min;
    var itemAtIndex = x[randomIndex];
    x[randomIndex] = x[i];
    x[i] = itemAtIndex;
  }

  alert(x);
}

function SwapValuesAtIndices(array, firstIndex, secondIndex) {
  var temp = array[firstIndex];
  array[firstIndex] = array[secondIndex];
  array[secondIndex] = temp;
  return array;
}

Further reading:

• Shuffling an array
• Generating a random number in a given range
• Swapping elements

Answer 7

Try something like this. It keeps the first and last elements in place without explicitly defining their values, and builds a new array with the other elements shuffled randomly.

 const x = ['A','B','C','D','E']; const shuffledArray = customShuffle(x); console.log(shuffledArray); function customShuffle(arr) { let newArray = []; const first = arr[0]; const last = arr[arr.length-1]; //First, remove the 'first' and 'last' values from array: for(let i=0; i<arr.length; i++){ if(arr[i] == first || arr[i] == last){ arr.splice(i, 1); } } //Next, add values to the new array at random: for(let i=0; i<arr.length; i++){ const indexToRemove = Math.floor( Math.random() * arr.length ); const value = arr[indexToRemove]; arr.splice(indexToRemove, 1); newArray.push(value); } //Last, add in the 'first' and 'last' values: newArray.unshift(first); newArray.push(last); return newArray; } 

Answer 8

Because you asked for elegant, I like to implement a more functional style of programming here. The code below does what you want. You supple the shuffle function with your array, the max number of times you want it shuffled (the higher the number, the better the shuffle is), and true to keep the first element in place, false to keep the last.

function shuffle(array, maxTimes, first) {
    var temp = (first) ? array.reverse().pop() : array.pop();

    Array.from(
        Array(Math.round(Math.random()*maxTimes))
            .keys()).forEach(val => array = array.reduce((acc,val) => 
                (Math.random() > 0.5) ? acc.concat([val]) : [val].concat(acc),[]));

    return (first) ? [temp].concat(array.reverse()) : array.concat([temp]);
}

Example usage:

shuffle(['A','B','C','D','E'], 10, true);

Output: ["A", "C", "D", "B", "E"]

I hope this is what you're looking for and answers your question.

Edit

Turns out you can get the shuffle logic all in one line (when removing the unnecessary newlines). When you add the two lines to retain the first or last character, you can essentially create this function with three lines of code.

Answer 9

    function SpecialShuffle(MyArray)
    {
    var newArray = [];
    var counter=  1;
    for(var i = MyArray.length-1 ; i>-1 ; i--)
    {
    if(i == MyArray.length)
    {
    newArray[i] = MyArray[i]
    }
    else if(i == 0 )
    {
    newArray[i]=MyArray[i];
    }
    else
    {
    newArray[counter] = MyArray[i];
    counter++;
    }
    }
return newArray;
    }