Discussion :

[mister3957]

Bonjour à tous,

J'ai un tableau avec des contraintes de capacités max, ex :

A:6 B:0 C:0 D:0 => Indique que l'on peut avoir 6A mais plus de place pour avoir ni de B, C ou D
A:5 B:2 C:0 D:0 => Indique que lorsque l'on a 5A, on peut avoir 2B mais plus de C ou de D
A:5 B:1 C:1 D:0 => Indique que lorsque l'on a 5A, on peut avoir 1B et 1C mais plus de D
Etc.

A noter que suite à ces exemples, le couple A:5 B:1 C:0 D:0 est valide (car inférieur à A:5 B:1 C:1 D:0 ou A:5 B:2 C:0 D:0 qui définit un seuil max).

Il y a une centaine de lignes de ce type vouées à évoluer avec le temps et pas de relations entre ces infos (1A n'est pas forcément équivalent à 2B, à 4C ou 8D).

Le soucis c'est que je n'ai droit qu'à des comparaisons binaires (==, !=, <, <=, >, >=) cumulatifs (&&). Par conséquent je cherche un truc, une fonction mathématique ou que sais-je pour, à partir d'un résultat produit via des infos A, B, C et D, effectuer l'une de ces comparaisons et déterminer une capacité max a été atteinte ou non.

L'objectif est de ne pas faire :
Si A=6 && B=0 && C=0 Alors D<=0
Si A=5 && B=2 && C=0 Alors D<=0
Si A=5 && B=1 && C=1 Alors D<=0
Etc. ce qui serait non maintenable

J'avais pensé à faire un truc du genre A * 1000000 + B * 100000 + C * 10000 + D * 1000 puis je me suis embrouillé tout seul.

Le bon truc est que je peux inclure ou programmer n'importe quel algorithme pour produire ce résultat intermédiaire avant de le comparer avec ces quelques comparaisons binaires.

Est-ce qu'il y a quelque chose de magique pour résoudre ce type de problématique ?

Merci à vous

A bientôt

[Sipige]

Tu dois faire une boucle pour compter le total de tableau.

[tbc92]

Tes contraintes sont de la forme A:Compteur_de_A B:Compteur_de_B C:Compteur_de_C D:Compteur_de_D.

Tu as donc 4 champs ( A B C et D) : question : Est-ce que ce nombre de champ est figé, et égal à 4.
Et tu as donc des compteurs. On va supposer que sur ta série de 35 lignes, les compteurs ne dépassent jamais 9. Sinon, il faudra adapter.

Comme les compteurs ne dépassent jamais 9, je vais prendre une ""Base"" égale à 10. ( Base supérieure au max des compteurs existants)

Et je vais traduire chaque contrainte
A:Compteur_de_A B:Compteur_de_B C:Compteur_de_C D:Compteur_de_D. --> total = B:Compteur_de_A * Base^3 + B:Compteur_de_B * Base^2 + B:Compteur_de_C * Base ^1 + B:Compteur_de_D * Base^0

Chacune des 100 contraintes correspond donc à un total différent.


Tu as ensuite un jeu de données, et pour ce jeu , tu veux savoir si une des contraintes a été atteinte.
Pour ce jeu, tu calcules donc le Total, avec la même règle , et tu regardes si le total est égal à l'un des 100 totaux cibles en question.

[mister3957]

Merci pour ta réponse,

J'y avais pensé mais malheureusement je n'ai pas l'opérateur "in values[]". Il faut que je l'implémente mais en ce moment je ne peux pas, d'où la recherche d'une alternative.

Merci encore

[wiwaxia]

Bonjour,

Tu es amené à manipuler des quadruplets de données q = (a, b, c, d) sur lesquels il te faut définir une relation d'ordre.

Une fonction F(Q1, Q2) qui prendrait les valeurs (+1, 0, -1) selon que l'on a: (Q1 > Q2 , Q1 = Q2 , Q1 < Q2) pourrait répondre à ce besoin, en n'utilisant des opérateurs booléens.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
TYPE Quad = RECORD  a, b, c, d: Byte  END;
 
FUNCTION F(Q1, Q2: Quad): ShortInt;
  VAR g: ShortInt; TestAB, TestBC, TestCD, TestE: Boolean;
  BEGIN
    TestCD:= (c>d)
    TestBC:= ((b>c) OR ((b=c) AND TestCD));
    TestAB:= ((a>b) OR ((a=b) AND TestBC));
    TestE:= ((a=b) AND ((b=c) AND (c=d)));
    IF TestAB THEN g:= 1
              ELSE IF TestE THEN g:= 0
                            ELSE g:= -1;
    F:= g
  END;

Tu pourrais ainsi définir les termes frontières à ne pas dépasser:

... A:6 B:0 C:0 D:0 => Indique que l'on peut avoir 6A mais plus de place pour avoir ni de B, C ou D
A:5 B:2 C:0 D:0 => Indique que lorsque l'on a 5A, on peut avoir 2B mais plus de C ou de D
A:5 B:1 C:1 D:0 => Indique que lorsque l'on a 5A, on peut avoir 1B et 1C mais plus de D
Etc ...

à savoir: (6, 0, 0, 0), (5, 2, 0, 0), (5, 1, 1, 0) ... cependant il manque encore quelques exemples, pour ce qui concerne le dernier terme (d):
(5, 1, 0, 1), (5, 0, 1, 1) ... ?