30:T8b2,So you're reviewing some code (someone else's, obviously ;P) and see a function that attempts to randomly shuffle an array. The results appear to be random permutations of the array, but the implementation is incorrect and doesn't select every permutation of the array with equal probability. The implementation is something like this: ```javascript function badShuffle(array) { for (let i = 0; i < array.length; i++) { const randomIndex = Math.floor(Math.random() * array.length); const temp = array[randomIndex]; array[randomIndex] = array[i]; array[i] = temp; } } ``` The problem is with `randomIndex`. For every `i`, we choose a random index *from the entire array* and swap the elements at those positions. We know that for an array of length `n`, there are `n!` permutations of it. Choosing the random index from the entire array for each element of the array will distribute the outputs randomly across `n`^`n` possibilities. Since `n`^`n` is greater than (and not a multiple of) `n!`, this means that some permutations are repeated more than others and are therefore more likely and this won't produce a truly random permutation of the array. So we've learned that you should instead only swap with the *remaining* elements of the array, that way when an element is placed, it can't be chosen again (i.e. choosing `n` items randomly without replacement). This will produce `n!` possible outputs which matches our expectation for the number of permutations of an array. Satisfied, you make the change and move on: ```javascript function shuffle(array) { for (let i = 0; i < array.length; i++) { const randomIndex = Math.floor((Math.random() - i) * array.length + i); const temp = array[randomIndex]; array[randomIndex] = array[i]; array[i] = temp; } } ``` One day I got curious to see what the actual distribution is for the `badShuffle` implementation. At the top of the notebook is a heatmap of the distribution of where each index starts (y-axis) and where it ends up in the array. Below is the same data but using lines to display the distribution for each starting index (the darkest magenta is the `0th` item and the bright green is the last item).31:[] 2e:{"title":"Bad Shuffle","cells":[{"id":0,"value":"# Bad Shuffle","pinned":false,"hidden":false,"mode":"md"},{"id":60,"value":"Plot.plot({\n width: Math.min(800, width),\n height: 500,\n marginLeft: 20,\n marginRight: 0,\n marginTop: 0,\n color: {\n // domain: [0, 80000],\n scheme: \"blues\"\n },\n marks: [\n Plot.cell(results, {\n sort: \"original\",\n x: (d) => d.i,\n y: (d) => d.original,\n fill: \"frequency\",\n inset: -3\n })\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":264,"value":"*Array length is ${length}. The distribution of where each starting index (y-axis) most often ends up after calling `badShuffle(array)`. ${Number(n).toLocaleString()} trials. Darker blue is more frequent.*","pinned":false,"hidden":false,"mode":"md"},{"id":223,"value":"$30","pinned":false,"hidden":false,"mode":"md"},{"id":173,"value":"Plot.plot({\n width: Math.min(800, width),\n marginLeft: 60,\n marginRight: 40,\n color: {\n scheme: \"warm\"\n },\n marks: [\n Plot.ruleY([0]),\n Plot.line(results, {\n sort: \"i\",\n x: \"i\",\n y: \"frequency\",\n stroke: \"original\"\n })\n ]\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":6,"value":"viewof n = Inputs.range([1e6, 1e7], {\n value: width < 500 ? 2e6 : 5e6,\n step: 1,\n label: \"Number of trials\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":20,"value":"viewof length = Inputs.range([1, 100], {\n value: width < 500 ? 20 : 30,\n step: 1,\n label: \"Array length\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":291,"value":"For every position *i* of the array (aside from 0) the most likely position an element ends up in is the position just before it, *i - 1*. The very first element in the array is just as likely to to end up in any position, but the elements after that are significantly more likely to end up just to the left of where they started.","pinned":false,"hidden":false,"mode":"md"},{"id":306,"value":"## What is the intuition behind this behavior?","pinned":false,"hidden":false,"mode":"md"},{"id":310,"value":"Please fork this notebook and help illuminate any of the following:\n\n- Why is the most likely position just to the left of the starting position?\n- Why does the max of each distribution together trace this nice curve?\n- Any other interesting observations?\n\nThank you!","pinned":false,"hidden":false,"mode":"md"},{"id":356,"value":"## Related\n\nJust encountered Mike Bostock's similar matrix diagram that shows similar results (you'll need to select \"naïve swap (i ↦ random)\" from the dropdown): https://bost.ocks.org/mike/shuffle/compare.html","pinned":false,"hidden":false,"mode":"md"},{"id":15,"value":"badShuffle = (array) => {\n const copy = [...array];\n for (let i = 0; i < copy.length; i++) {\n const randomIndex = Math.floor(Math.random() * copy.length);\n const temp = copy[randomIndex];\n copy[randomIndex] = copy[i];\n copy[i] = temp;\n }\n return copy;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":29,"value":"results = {\n const array = Array.from({ length: length }, (_, i) => i);\n const counts = array.map(() => Object.fromEntries(array.map((i) => [i, 0])));\n for (let i = 0; i < n; i++) {\n badShuffle(array).forEach((d, i) => counts[d][i]++);\n }\n\n return Object.entries(counts).flatMap(([original, counts]) =>\n Object.entries(counts).map(([i, count]) => ({\n i: +i,\n frequency: count,\n original: +original\n }))\n );\n}","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W31","stdlib":"1","titling":"auto"}