Algoritmo per un'interfaccia utente che mostra cursori di percentuale X i cui valori collegati sono sempre pari al 100%

Algoritmo goloso

Quando un cursore si sposta verso l'alto (in basso), tutti gli altri devono spostarsi verso il basso (su). Ognuno ha uno spazio che può spostare (per il basso - la loro posizione, per sopra: 100-posizione).

Quindi quando si muove un cursore, prendi gli altri cursori, ordinali per lo spazio che possono spostare e semplicemente itera attraverso di essi.

Ad ogni iterazione, sposta il dispositivo di scorrimento nella direzione desiderata per (totale per spostare a sinistra / i cursori lasciati in coda) o la distanza che può spostare, a seconda di quale sia più piccolo.

Questo è lineare nella complessità (dal momento che è possibile utilizzare la stessa coda ordinata più e più volte, una volta che è stata ordinata).

In questo scenario, nessun cursore si blocca, tutti cercano di muoversi il più possibile, ma solo fino alla loro giusta quota.

Spostamento ponderato

Un approccio diverso sarebbe quello di ponderare la mossa che devono fare. Io penso questo è quello che hai cercato di fare, a giudicare dalla tua frase "i cursori rimangono bloccati a 0". IMHO questo è più naturale, hai solo bisogno di fare più ritocchi.

Speculando di nuovo, direi che provi a pesare le mosse di diversi cursori in base alla loro posizione (questo si tradurrebbe direttamente nel tuo problema bloccato a 0). Tuttavia, tieni presente che puoi visualizzare la posizione del cursore da direzioni diverse, dall'inizio o dalla fine. Se pesi per posizione dall'inizio alla diminuzione e posizioni dalla fine quando aumenti, dovresti evitare il tuo problema.

Questo è abbastanza simile nella terminologia alla parte precedente - non ponderare la mossa da fare per la posizione dei cursori, pesarla lo spazio che hanno lasciato per muoversi in quella direzione.

L'approccio che prenderei è leggermente diverso e comporta l'uso di una diversa rappresentazione interna di ciascun cursore.

1. ogni cursore può assumere qualsiasi valore da 0..100 (X) che viene usato come fattore di ponderazione per quel cursore (non a%)

2. somma tutti i valori del cursore per ottenere la cifra totale (T)

3. per determinare il valore visualizzato di ciascun cursore, usa ROUND (X * 100 / T)

4. quando un cursore viene spostato verso l'alto o verso il basso, cambi solo il valore del cursore 1 ; la ponderazione per quel cursore aumenterà o diminuirà rispetto a tutti gli altri cursori, e il calcolo sopra assicurerà che la modifica di tutti gli altri cursori sia distribuita nel modo più uniforme possibile.

Penso che tu stia complicando eccessivamente le cose provando ad aggiustare il valore corrente di una percentuale della variazione del cursore "spostato", che ti dà percentuali di percentuali, che sta introducendo errori di arrotondamento.

Dal momento che sai che hai sempre a che fare con un valore totale di 100, manterrei le cose come numeri interi e lavorerò all'indietro rispetto al 100, evitando qualsiasi problema serio con gli arrotondamenti. (Nell'esempio seguente gestisco ogni arrotondamento come interi interi alla fine)

La mia tecnica sarebbe quella di impostare i cursori come semplici 0-100. Sottrarre il valore "nuovo" da 100 per calcolare quanto ridistribuire, distribuirlo tra gli altri cursori in base al loro peso, quindi pulire)

Questo non è, per quanto ne so, codice Android valido: p

// see how much is "left" to redistribute
amountToRedistribute = 100 - movedSlider.value

//What proportion of the original 100% was contained in the other sliders (for weighting)
allOtherSlidersTotalWeight = sum(other slider existing values)

//Approximately redistribute the amount we have left between the other sliders, adjusting for their existing weight
for each (otherSlider)
    otherSlider.value = floor(otherSlider.value/allOtherSlidersWeight * amountToRedistribute)
    amountRedistributed += otherSlider.value

//then clean up because the floor() above might leave one or two leftover... How much still hasn't been redistributed?
amountLeftToRedistribute -= amountRedistributed

//add it to a slider (you may want to be smarter and add in a check if the slider chosen is zero, or add it to the largest remaining slider, spread it over several sliders etc, I'll leave it fairly simple here)
otherSlider1.value += amountLeftToRedistribute 

Questo dovrebbe intrinsicamente gestire qualsiasi valore 0 o 100

Che ne pensi di Round Robin? Crea una transazione che assicuri che l'aggiunta di valore a un cursore si riduca dal suo peer. e viceversa.

Quindi ogni volta che una modifica del cursore esegue la transazione con un cursore peer diverso (creerei un iteratore che restituisce il cursore peer a turno). Se il cursore peer è zero, passa a quello successivo.

Solo per approfondire la grande risposta di Greedy Algorithm di @Ordous. Ecco una ripartizione dei passaggi.

1. Muovi il cursore
2. Salva differenceAmount spostato come newValue - oldValue (valore positivo significa che è stato spostato verso l'alto e altri cursori devono spostarsi verso il basso e viceversa )
3. Ordina gli altri nell'elenco da almeno alla maggior parte di distanza che possono spostare nella direzione richiesta da differenceAmount positivo o negativo.
4. Imposta amountToMove = differenceAmount / rimanente OthersCount
5. Passa in rassegna e sposta ciascun cursore di o la quantità che può spostare o amountToMove . Qualunque sia il più piccolo
6. Sottrai l'importo che il cursore ha spostato da amountToMove e divide per nuovo rimanente OthersCount
7. Una volta terminato, hai distribuito con successo differenceAmount tra gli altri slider.

Una tecnica semplice consiste nel calcolare le percentuali dei valori del cursore relativamente alla somma dei valori del cursore e quindi riassegnare i valori del cursore alle rispettive percentuali calcolate. in questo modo i valori dei cursori saranno riadattati e.g

slider1.value = (slider1.value / sumOfSliderValues) * 100 ;
slider2.value = (slider2.value / sumOfSliderValues) * 100 ;
slider3.value = (slider3.value / sumOfSliderValues) * 100 ;

Sebbene introduca un errore di arrotondamento, ma può essere gestito nel caso in cui avessimo bisogno dei valori dei cursori esattamente e sempre di sommare fino a 100.

Ho impostato un violino per dimostrarlo usando angularjs. Si prega di visitare demo