Un système que je construis comprend un ensemble de curseurs d'interface utilisateur (le nombre varie) chacun avec une échelle de 0 à 100. Par curseur, je veux dire une interface utilisateur où vous saisissez un élément et le faites glisser de haut en bas, comme un contrôle de volume. Ils sont connectés par un algorithme qui garantit qu'ils totalisent toujours 100. Ainsi, lorsqu'un curseur est déplacé vers le haut, les autres se déplacent tous vers le bas, éventuellement jusqu'à zéro. Quand l'un est descendu, les autres montent. En tout temps, le total doit être de 100. Donc, ici, les curseurs ont différentes valeurs, mais ils totalisent 100%:
----O------ 40
O---------- 0
--O-------- 20
--O-------- 20
--O-------- 20
Si le premier curseur monte ensuite de 40 à 70, les autres doivent descendre en valeur (lorsque le curseur est déplacé). Notez que trois curseurs sont passés de 20 à 10, et un est resté à zéro car il ne peut pas descendre plus bas.
-------O--- 70
O---------- 0
-O--------- 10
-O--------- 10
-O--------- 10
Bien sûr, lorsqu'un curseur atteint 0 ou 100, il ne peut plus bouger, c'est là que ma tête commence vraiment à me faire mal. Donc, si un curseur monte plus haut, les autres descendent plus bas, mais quand l'un d'eux atteint zéro, seuls les autres qui n'ont pas encore atteint zéro peuvent descendre plus bas.
Je pose cette question ici car cette question est spécifique à l'algorithme et non à l'implémentation. La plateforme FWIW est Android Java, mais ce n'est pas particulièrement pertinent.
L'approche que j'ai adoptée avec mon premier coup de couteau a été de calculer le pourcentage de variation du curseur qui s'est déplacé. J'ai ensuite divisé ce changement et l'ai appliqué (dans l'autre sens) aux autres valeurs du curseur. Le problème est cependant qu'en utilisant des pourcentages et en multipliant, si un curseur arrive à zéro, il ne peut jamais être augmenté à nouveau à partir de zéro - le résultat net est que les curseurs individuels restent bloqués à zéro. J'ai utilisé des curseurs avec une plage de 0 à 1 000 000 pour éviter les problèmes d'arrondi et cela semble être utile, mais je n'ai pas encore créé d'algorithme qui gère bien tous les scénarios.