calcul de largeur

alexis
Les bases Algorithmique

Bonjour, je viens sur ce forum car j'ai un problème pour la création d'un algorithme. L'algorithme consisterai en fait : On part d'une largeur fixe appelé L par exemple et je veux diviser cette largeur en n sous-largeur, et je voudrais que pour chaque valeur de sous-largeur elle soit un random compris en 150 et 200 et que cet algorithme retourne chaque sous-largeur. Pour illustrer : Je prends L = 500px par exmple** X1 = 160, X2 = 168, X3 = 172** J'ai donc bien un random compris entre 150 et 200 pour chaque X et la somme de X1 + X2 + X3 = 500 = L** Or je voudrais généraliser ce cas, et que le nombre de sous-largeur dépende de la largeur L, comment puis-je réaliser cet algorithme ? Merci

2 réponses

Wakser

Salut Ton algorithme est simple à réaliser: -Tu déclares : Une variable **nbr** qui prendra comme valeur le nombre de sous-largeurs désirées (exemple 3). Une variable **L** qui prendra une largeur fixe (exemple 500). Une variable tu type tableau ou sera affecter les nouvelles largeurs. Une variable somme. -tu boucle de 0 à nbr. -tu ajoute à ta boucle une condition qui dit : *si l'indice de la boucle est égale 0 alors on affectera une valeur aléatoire (ne dépassant pas les L=500) à notre première case du tableau (t[0]). *sinon si l'indice est égale à nbr-1(la fin de la boucle) alors on effacera à cette case du tableau une valeur qui égale à : la largeur fixe L (500) moins la somme de toutes les cases. *sinon la case du tableau prendra comme valeur une valeur aléatoire qui ne dépasse pas la case précédente . Un exemple en langage C pour t'éclaircir : [code]int L=500,nbr=5,somme=0,i,largeurs[5]; for(i=0;i<nbr if largeurs else somme printf :></nbr>

Makai

D'après ce que j'ai compris, tu souhaites plutôt avoir un nombre aléatoire de sous-division mais qu'elles dépendent d'un minimum et d'un maximum.

J'ai trouvé quelque chose qui respecte a peu près ce qui tu avais demandé :

Je génère une liste de sous-divisions dont la largeur oscille aléatoirement entre ton min (ici 150) et ton max (200).

La somme de toutes les sous-divisions est égale à ta largeur (500).

Mon seul hic est que la dernière division ne sera probablement pas comprise entre la fourchette prédéfini, le total étant dans ce cas soit supérieur , soit inférieur à la largeur souhaitée.

Voici une représentation en Groovy(Java) (GroovyConsole d'ouverte :p) :

// Déclarations des constantes
def largeur = 500
def min = 150
def max = 200
// Calcul du nombre maximum de divisions arrondi à l'entier supérieur pour être sûr d'avoir notre largeur totale
int nombreMaxDivision = Math.ceil(largeur / min)
// Liste contenant la largeur des sous-divisions
List divisions = ]
// Génération des sous-divisions
for(i=0;i<nombreMaxDivision; i++) {
    // Une nouvelle division d'une largeur aléatoire comprise entre min & max
    int div = (Math.random() * (max-min)) + min;
    // Si la nouvelle division + les anciennes est supérieur à largeur, la nouvelle division sera égale au reste
    int sum = divisions.sum() ?: 0
    div = (div < largeur - sum) ? div : largeur - sum
    // Ajout de la nouvelle division à la liste
    divisions += div
}
// Suppression des sous-divisions dont la largeur = 0
divisions.removeAll{ it == 0 }