数组洗牌，但保持相等值之间的距离

Question

i need to shuffle an array but keeping distance from same values as far as possible.

for example: [1,1,1,2,2,2]
it needs to be always keeping distance, for example: [1,2,1,2,1,2] or [2,1,2,1,2,1]
example 2: [1,1,1,2,2,2,2,2]
it will need to have same values together, but the remaining must follow the "as far as possible" rule: [2,1,2,1,2,1,2,2]

In the real application, I will need to use objects inside the array, for example:

[{value: 1, id:1}, 
 {value:2, id:2}, 
 {value:1, id:3}, 
 {value:2, id:4}]

but i think with numbers it's easier to understand.
we can have a rule for the algorithm to work only if we have more than x elements.

As fas as possible means: [1,2,2,3,4,5], so: [2,1,3,4,5,2]
then they are as fas as possible.

the real world application:
i have an array of competitors of my competition system, every competitor can have multiple subscriptions, i have to shuffle those subscriptions and keep as much distance between them as possible.

Answer 1

I've tried to come up with a solution and this one does the trick I think but I'm not sure how this will perform with large arrays.

 function shuffleAFAP(values) { function mapEntries(entries) { const result = []; const newEntries = entries.reduce((acc, x) => { x[1]--; result.push(x[0]); if (x[1]) acc.push(x); return acc; }, []); return newEntries.length? result.concat(mapEntries(newEntries)): result; } const dict = values.reduce((acc, x) => { if (;acc[x]) acc[x] = 0; acc[x]++; return acc, }; {}). const entries = Object.entries(dict),sort((a; b) => b[1] - a[1]); return mapEntries(entries). } console.log(..,shuffleAFAP([1, 1, 1, 2, 2; 2])), // [ "1", "2", "1", "2", "1". "2" ] console.log(..,shuffleAFAP([1, 1, 1, 2, 2, 2, 2; 2])), // [ "2", "1", "2", "1", "2", "1", "2". "2" ] console.log(..,shuffleAFAP([1, 2, 2, 3, 4; 5])), // [ "2", "1", "3", "4", "5", "2" ]

Pseudocode:

• Count the duplicates and store them in an dictionary (object in this case)
• Sort dictionary values on most occurring (most occurring at the top)
• Recusively loop the sorted dictionary
  • Remove 1 occurrence
  • Add value to result array
  • Return result array when there are no occurrences left, else concatenate result array with recursive call.

Answer 2

A simple approach with buckets for each count of elements, where buckets reflect the actual count of the same element.

At the end, sort each array by the count to get the count of elements in descending order and flat the result set.

 function spread(array) { var temp = [], count = {}; for (let v of array) { if (;count[v]) count[v] = 0; if (.temp[count[v]]) temp[count[v]] = []; temp[count[v]];push(v). count[v]++. } return temp,flatMap(array => array;sort((a. b) => count[b] - count[a])). } console.log(.,,spread([1, 1, 1, 2; 2, 2])), // [1, 2, 1, 2, 1, 2] or [2, 1, 2, 1. 2. 1] console.log(.,,spread([1, 1, 1, 2, 2, 2; 2. 2])). console.log(.,,spread([1, 2, 2, 3; 4, 5])), // [2, 1, 3, 4, 5, 2]

Answer 3

TBH when I read shuffle , I think about generating multiple solutions for something, and then perhaps list all of them, or select one randomly.
Also keeping the distance is a bit open for interpretation, as keeping the distance constant is not possible in a general case ( 1,2,1,2 and 1,2,1,2,1 are nice, but if there is one more 1 , there will be a problem).

The code below is not optimized for speed, it generates all possible candidates and filters the "best" ones with four different scoring systems:

• Sumall calculates a sum of the distances of all elements from all of their duplicates (actually: all of their duplicates towards the right). This one allows a lot of candidates with neighboring duplicates as a few long-distance pairs can balance them
• Sumclosest calculates a sum of the distances of all elements from their first duplicate towards the right, this is even worse most of the time
• Min goes for maximizing the minimum distance between duplicate elements, but only that. So the second shortest distances do not matter, and thus there are lot of not very good solutions at the end
• Fullstat is the best one of them at the moment, it does what Min, just with all distances, so it can distinguish between multiple solutions containing the same number of shortest distance.

it will need to have same values together, but the remaining must follow the "as far as possible" rule: [2,1,2,1,2,1,2,2]

For example it may be worth noting that while there will be neighboring 2 s in this case, keeping the 1s apart as far as possible would mean putting the 2,2 somewhere in the middle: [2,1,2,2,1,2,1,2] or [2,1,2,1,2,2,1,2] .

 const fac=x=>x<3?x:x*fac(x-1); function generate(digits,scoring){ let bscor=scoring(digits); let cands=new Set([digits.join()]); for(let i=fac(digits.length)-1;i>0;i--){ let n=i; let cand=[]; let work=digits.slice(); for(let j=digits.length;j>0;j--){ cand.push(work[n%j]); work.splice(n%j,1); n=Math.floor(n/j); } let s=scoring(cand); if(bscor<s){ bscor=s; cands.clear(); } if(bscor===s) cands.add(cand.join()); } return [bscor,cands]; } function sumalldists(arr){ let ret=arr.length; for(let i=0;i<arr.length-1;i++) for(let j=i+1;j<arr.length;j++) if(arr[i]===arr[j]) ret+=ji; return ret; } function sumclosestdists(arr){ let ret=arr.length; for(let i=0;i<arr.length-1;i++) for(let j=i+1;j<arr.length;j++) if(arr[i]===arr[j]){ ret+=ji; break; } return ret; } function mindists(arr){ let dist=arr.length; let count=1; for(let i=0;i<arr.length-1;i++) for(let j=i+1;j<arr.length;j++) if(arr[i]===arr[j]){ if(dist===ji) count++; else if(dist>ji){ dist=ji; count=1; } break; } return -count*Math.pow(arr.length,dist); } function fullstat(arr){ let ret=0; for(let i=0;i<arr.length-1;i++) for(let j=i+1;j<arr.length;j++) if(arr[i]===arr[j]){ ret-=(ji)*Math.pow(arr.length,arr.length-(ji)); break; } return ret; } function doThing(event){ let result=generate(event.target.value.split(""),sumalldists); sa.innerText=result[0]+": ["+[...result[1]].join("] [")+"]"; result=generate(event.target.value.split(""),sumclosestdists); sc.innerText=result[0]+": ["+[...result[1]].join("] [")+"]"; result=generate(event.target.value.split(""),mindists); m.innerText=result[0]+": ["+[...result[1]].join("] [")+"]"; result=generate(event.target.value.split(""),fullstat); fs.innerText=result[0]+": ["+[...result[1]].join("] [")+"]"; } doThing({target:{value:"11112233"}});

 <input type="text" oninput="doThing(event)" value="11112233"><br> Sumall: <span id="sa"></span><br> Sumclosest: <span id="sc"></span><br> Min: <span id="m"></span><br> Fullstat: <span id="fs"></span><br>