Algorithme de redimensionnement des colonnes

Question

J'ai un ensemble de colonnes de largeurs variables et j'ai besoin d'un algorithme pour les redimensionner pour une certaine valeur y qui est supérieure à la somme de toutes leurs largeurs.

Je voudrais que l'algorithme priorise l'égalisation des largeurs. Donc, si j'ai une valeur qui est absolument énorme, les colonnes finiront avec plus ou moins la même largeur. S'il n'y a pas assez de place pour cela, je veux donner la préférence aux plus petites cellules.

Des idées sensationnelles? Je préfère quelque chose d'aussi simple que:

getNewWidths(NewWidth, ColumnWidths[]) returns NewColumnWidths[] 

Answer 1

pseudocode:

w = NewWidth 
n = ColumnWidths.count 
sort(ColumnWidths, ascending) 
while n > 1 and ColumnWidths[n-1] > (w/n): 
    w = w - ColumnWidths[n-1] 
    n = n - 1 
for i = 0 to n-1: 
    ColumnWidths[i] = w/n 

Vous aurez besoin d'ajouter un peu de code pour redistribuer les roundoffs du calcul w/n, mais je pense que cela va le faire .

Answer 2

Je décompose qu'en deux étapes, d'abord décider combien vous voulez égalisation (entre 0 et 1) et seulement en second lieu l'adapter à la nouvelle largeur totale.

Par exemple, comme dans

def get_new_widths new_total, widths 
    max = widths.max 
    f = how_much_equalizing(new_total) # return value between 0.0 and 1.0 
    widths = widths.collect{|w| w*(1-f)+max*f} 
    sum = widths.inject(0){|a,b|a+b} 
    return widths.collect{|w| w/sum*new_total} 
end 

def how_much_equalizing new_total 
    return [1.0, (new_total/2000.0)].min 
end 

Answer 3

La réponse de Mark Ransom donne l'algorithme droit, mais si vous avez des difficultés à comprendre ce qui se passe là-bas, voici une implémentation réelle en Python:

def getNewWidths(newWidth, columnWidths): 
    # First, find out how many columns we can equalize 
    # without shrinking any columns. 
    w = newWidth 
    n = len(columnWidths) 
    sortedWidths = sorted(columnWidths) # A sorted copy of the array. 
    while sortedWidths[n - 1] * n > w: 
     w -= sortedWidths[n - 1] 
     n -= 1 

    # We can equalize the n narrowest columns. What is their new width? 
    minWidth = w // n # integer division 
    sparePixels = w % n # integer remainder: w == minWidth*n + sparePixels 

    # Now produce the new array of column widths. 
    cw = columnWidths[:] # Start with a copy of the array. 
    for i in range(len(cw)): 
     if cw[i] <= minWidth: 
      cw[i] = minWidth 
      if sparePixels > 0: 
       cw[i] += 1 
       sparePixels -= 1 
    return cw