Discussion :

[Fixette2000]

Et bien merci encore.

wiwaxia/tbc92
Je dois être honnête, CliffeCSTL m'ayant donné un moyen rapide de vérifier ses codes, je me suis focalisé sur ses codes/langage, sachant qu'il y a une semaine je ne connaissais rien à tout ça, j'essaye déjà d'assimiler ce que j'aarrive à comprendre.

Mais, cette fois-ci, je ne comprend pas le résultat. il me donne une réponde de type: ([0, 0, 0, 2], 3), longueur utilisée = 175.0
C'est bien une symétrie s'il y a un cadre, ou 2 similaires, ou 2similaires + 1 cadre seul.
Mais là, pour des entrées de cadres 30/40/50/70cm, La dimension utilisée semble fausse

que veut dire le 3?

[Fixette2000]

Et question con:

La solution optimale en symétrie est probablement contenue dans les solutions optimales sans contraintes?
N'est-il pas possible dans ce cas d'afficher dans les meilleurs solutions la solution optimale sans contraintes et la solution symétrie?
En gros de fusionner les 2 codes?

[tbc92]

1. Oui à Wiwaxia, pour tester si une solution est symétrique, on teste si les nombres de tableaux par taille sont tous pairs, ou si au maximum, un de ces nombres est impair.
2. Oui, avec cette méthode, on peut adapter le programme pour qu'il fasse le recensement une seule fois, et qu'il affiche à la fin la meilleure combinaison dans l'absolu, et la meilleure combinaison symétrique.
3. J'aimerais bien faire la modification à partir de code Python, mais sur la variante 'récursive', j'en suis incapable.
Si le nombre de tailles de tableaux est limité à 4 ou 5, alors je dois pouvoir adapter la 1ère version du code Python de CliffeCSTL.
Je peux aussi te proposer une version récursive dans mon langage favori.

[CliffeCSTL]

([0, 0, 0, 2], 3) ça veut dire 2 cadres du dernier type + la moitié du cadre de 3ème type (sachant que l'on commence la numérotation à 0)

[Fixette2000]

Merci tbc92, pour l'instant j'essaye de me focaliser sur un langage pour comprendre le processus, mais il est certain que, ne sachant pas comment (sur quel support) je vais utiliser ça au final, tout code sous différent langage m'intéresse mais je peux pas l'exiger...peut-être que je me ferais faire un petit logiciel perso par mon seul pote programmateur (que j'ai déjà bien sollicité par le passé), et je ne connais pas ses langages de prédilection.
Par défaut j'enregistre tout ce que vous me dites, espérant pouvoir mieux décortiquer ça plus tard.

CliffeCSTL:
ok je comprend mieux. Mais il semble qu'il y a une erreur tout de même:

pour les données suivantes:
L = 300 # Taille de la moitié du mur
e_b = 6 # Espace sur les cotés du mur
e_c = 8 # Espace entre les cadres
# Définition des cadres
l_cadre = [
(30, 999999),
( 40, 999999),
( 50, 999999),
( 70, 999999),]

J'obtiens:
Meilleure solution : ([0, 0, 1, 3], None), longueur utilisée = 260
Ce n'est donc pas une symétrie...
sauf si on considère qu'il faille rentrer comme longueur de mur la moitié du mur?
C'est à dire qu'en rentrant 300cm, je veux remplir un mur de 600cm...c'est bien ça?

[Fixette2000]

heinn...

je suppute qu'il y ait une erreur du fait de travailler sur la moitié d'un mur...car du coup, il y a un écarts entre cadre qui est coupé en 2.
On considère 8cm d'écart (4cm + 4cm par cadre)...

d'où la suggestion de wiwaxia de ne pas travailler sur 1/2 mur?

Quelle enquête à retardement je fais! ahaha

[tbc92]

Si ton pote est programmateur, il ne t'aidera pas beaucoup sur cette question. Par contre, s'il est programmeur, ça devrait marcher.

[Fixette2000]

Effectivement, j'ai pas le bon vocabulaire
Si on dit qu'il est développeur ça marche pour tout? algorithme, programme, interface??
Je crois qu'il est loin de votre niveau cela dit...

[CliffeCSTL]

Oui il faut saisir la moitié du mur, c'est noté dans le commentaire

Il y a une petite erreur dans mon code, si on ne prend pas de moitié de cadre il faut rajouter un demi écart supplémentaire dans la solution :

https://onlinegdb.com/SJdyOrx9B



Concernant le langage, pour en avoir tester pas mal, je te conseil vivement python

[Fixette2000]

ah ba oui...c'est sympa de me mettre des petits pièges pour voir si je suis bien concentré

[Fixette2000]

CliffeCSTL
après tests, ça semble fonctionner parfaitement! C'est top

Pour pas me gourer dans la saisie, j'ai rajouté une saisie de la taille totale du mur, à la barbare:

Ltotal = 500 # Taille Totale du mur
L = Ltotal/2 # Taille de la moitié du mur

Par curiosité, est-ce que c'est le genre de truc qui alourdi les codes, d'une manière générale?
Je veux dire, de mettre une fonction directe qui rentre dans d'autres fonction, c'est le genre de truc à éviter si possible?

[wiwaxia]

J'ai regardé ce que donnait le programme pour L = 500 et 600 cm.

La largeur totale correspond à la somme des largeurs effectives, la distance résiduelle à l'écart réel séparant le bord du cadre le plus proche de l'extrémité du mur (la distance entre 2 tableaux voisins étant maintenue à 8 cm)

L'algorithme n'a pas présenté de surprises, et s'exécute rapidement.

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 PROGRAM Disposition_Tableaux;
 
 USES Crt, E_Texte;
 
 CONST La0 = 70;      Lb0 = 50;
       Lc0 = 40;      Ld0 = 30;
       Lm0 = 500;                       // Dimensions intrinsŠques
       Et = 8;        Em = 6;           // Ecarts impos‚s
       La = La0 - Et; Lb = Lb0 - Et;    // Dimensions effectives
       Lc = Lc0 - Et; Ld = Ld0 - Et;
       Lm = (Lm0 + Et) - (2 * Em);
       X0 = 5;        X1 = X0 + 30;     // Directives d'affichage
       Y0 = 10;       Y1 = Y0 + 3; o = 5;
 
 PROCEDURE AffLtNabcd(Lt, Ka, Kb, Kc,Kd: Word);
   VAR d: Reel;
   BEGIN
     E(0010);               We(X1, Y1, Lt, o);
     E(0014);               Write(Ka:o, Kb:o, Kc:o, Kd:o); E(0700);
     d:= (Lm0 - Lt + Et)/2; Wr(X1, Y1 + 3, d, 502)
   END;
 
 FUNCTION F_Parite(Ka, Kb, Kc, Kd: Word): Bool;
   VAR s: Byte;
   BEGIN
     s:= Ka MOD 2;     Inc(s, Kb MOD 2);
     Inc(s, Kc MOD 2); Inc(s, Kd MOD 2);
     Result:= (s<2)
   END;
 
 PROCEDURE Comparaison(Lt, Ja, Jb, Jc, Jd: Word;
                       VAR Lt_, Ja_, Jb_, Jc_, Jd_: Word);
   VAR TestA, TestB, TestC, TestL, TestP, TestLP, TestABC: Bool;
   BEGIN
     TestL:= (Lt>Lt_); TestP:= F_Parite(Ja, Jb, Jc, Jd);
     TestA:= (Ja>Ja_); TestB:= (Jb>Jb_); TestC:= (Jc>Jc_);
     TestLP:= (TestL AND TestP);
     TestABC:= TestA AND (TestB AND TestC);
     IF (TestLP AND TestABC) THEN
       BEGIN
         Lt_:= Lt; Ja_:= Ja; Jb_:= Jb; Jc_:= Jc;
         Jd_:= Jc; AffLtNabcd(Lt, Ja, Jb, Jc, Jd)
       END
   END;
 
 PROCEDURE AffNq(k: LongInt);
   BEGIN
     E(0012); We(X1, Y0, k, o)
   END;
 
 PROCEDURE Enumeration;
   VAR Iam, Ibm, Icm, Idm,
       Ia, IaMax, Ib, IbMax, Ic, IcMax, Id, IdMa,
       L1, L2, L3, Ltot, Ltm: Word; Nq: LongInt;
   BEGIN
     Iam:= 0; Ibm:= 0; Icm:= 0; Idm:= 0;
     Ltm:= 0; Nq:= 0;
     IaMax:= Lm DIV La;
     FOR Ia:= 1 TO IaMax DO
       BEGIN
         L1:= Lm - (Ia * La); IbMax:= L1 DIV Lb;
         IF (IbMax>0) THEN
           FOR Ib:= 1 TO IbMax DO
             BEGIN
               L2:= L1 - (Ib * Lb); IcMax:= L2 DIV Lc;
               IF (IcMax>0) THEN
                 FOR Ic:= 1 TO IcMax DO
                   BEGIN
                     L3:= L2 - (Ic * Lc); Id:= L3 DIV Ld;
                     Ltot:= Ia * La;      Inc(Ltot, Ib * Lb);
                     Inc(Ltot, Ic * Lc);  Inc(Ltot, Id * Ld);
                     IF (Id>0) THEN
                       BEGIN
                         Inc(Nq); AffNq(Nq);
                         Comparaison(Ltot, Ia, Ib, Ic, Id,
                                     Ltm, Iam, Ibm, Icm, Idm)
                       END
                   END
             END
       END;
     A_
   END;
 
 PROCEDURE AffT;
   CONST L1 = 10; o = 5;
   BEGIN
     E(1015); Wt(X0, Y0 - 3, '( Lm0, La0, Lb0, Lc0, Ld0 )');
     Wt(X0, Y0, 'Nombre de quintuplets calcul‚s:');
     Wt(X0, Y1, '( Lt, Na, Nb, Nc, Nd ) =');
     Wt(X0, Y1 + 3, 'Distance r‚siduelle: d = ');
     E(0009); We(X1, Y0 - 3, Lm0, o);
     E(0011); Write(La0:o, Lb0:o, Lc0:o, Ld0:o)
   END;
 
 BEGIN
   AffT; Enumeration
 END.

Le critère de choix

Code :

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

1
2
3
4
5
     TestL:= (Lt>Lt_); TestP:= F_Parite(Ja, Jb, Jc, Jd);
     TestA:= (Ja>Ja_); TestB:= (Jb>Jb_); TestC:= (Jc>Jc_);
     TestLP:= (TestL AND TestP);
     TestABC:= TestA AND (TestB AND TestC);
     IF (TestLP AND TestABC) THEN

n'établit pas de hiérarchie sur la recherche de la plus grande largeur, en ce qui concerne les cadres (A, B, C), et cela ne traduit peut être pas exactement ce que tu souhaitais:

Cas3: je veux utiliser en priorité les plus grands cadres (en dernier lieu les plus petits cadres, par exemple A+A+A+A+C+C+C+BB+A) quitte à accepter une solution de 10% moins optimale que la solution du cas 1 (ou*cas2)
=(algorithme glouton/division euclydienne)

Je rectifierai cela; il suffit de reprendre l'expression du booléen TestABC.

[Fixette2000]

Cool Merci

Bon il faut que je fasses des traductions maintenant

[wiwaxia]

J'ai donc repris la sélection des arrangements; la disposition des parenthèses était peu claire, et probablement incorrecte.

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
 
 PROCEDURE Comparaison01(Lt, Ja, Jb, Jc, Jd: Word;
                       VAR Lt_, Ja_, Jb_, Jc_, Jd_: Word);
   VAR TestP, TestBC, TestABC, TestLABC: Bool;
   BEGIN
     TestP:= F_Parite(Ja, Jb, Jc, Jd);
     TestBC:= (Jb>Jb_) OR ((Jb=Jb_) AND (Jc>Jc_));
     TestABC:= (Ja>Ja_) OR ((Ja=Ja_) AND TestBC);
     TestLABC:= (Lt>Lt_) OR ((Lt=Lt_) AND TestABC);
     IF (TestLABC AND TestP) THEN
       BEGIN
         Lt_:= Lt; Ja_:= Ja; Jb_:= Jb; Jc_:= Jc;
         Jd_:= Jc; AffLtNabcd(Lt, Ja, Jb, Jc, Jd)
       END
   END;

Cette nouvelle procédure a conduit aux résultats suivants:

L'étendue couverte est cette fois maximale: (d) est réduite à sa valeur minimale (6 cm); et l'on observe une nette augmentation de (Na).

[wiwaxia]

Et question con:La solution optimale en symétrie est probablement contenue dans les solutions optimales sans contraintes?
N'est-il pas possible dans ce cas d'afficher dans les meilleurs solutions la solution optimale sans contraintes et la solution symétrie?
En gros de fusionner les 2 codes?

Yaka voir ce que donne la nouvelle sélection, plus simple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 PROCEDURE Comparaison02(Lt, Ja, Jb, Jc, Jd: Word;
                       VAR Lt_, Ja_, Jb_, Jc_, Jd_: Word);
   VAR TestBC, TestABC, TestLABC: Bool;
   BEGIN
     TestBC:= (Jb>Jb_) OR ((Jb=Jb_) AND (Jc>Jc_));
     TestABC:= (Ja>Ja_) OR ((Ja=Ja_) AND TestBC);
     TestLABC:= (Lt>Lt_) OR ((Lt=Lt_) AND TestABC);
     IF TestLABC THEN
       BEGIN
         Lt_:= Lt; Ja_:= Ja; Jb_:= Jb; Jc_:= Jc;
         Jd_:= Jc; AffLtNabcd(Lt, Ja, Jb, Jc, Jd)
       END
   END;

On obtient pour les mêmes valeurs de la largeur du mur:

L'étendue de la zone couverte est toujours maximale - il fallait s'y attendre; 3 nombres impairs interviennent dans le second cas, pour lequel (Na) est plus élevé (7 au lieu de 6).
Le nombre de combinaisons est relativement réduit, en raison des contraintes imposées; on observerait probablement des réponses très différentes sur un mur plus long.

[wiwaxia]

Le programme fonctionne encore sur de plus grandes largeurs

... je n'aurais pas de murs de plus de 35 m à priori ...

et, comme on pouvait s'y attendre, la durée d'exécution est plus grande, et l'étendue couverte maximale que l'on impose (Comparaison01) ou non (Comparaison02) la condition de parité:

Compte tenu du déséquilibre observé en faveur des tableaux de grande dimension, il devient peut-être opportun d'en limiter supérieurement le nombre de chaque sorte, ce qui s'obtient par des corrections mineures.

Le nombre de combinaisons calculées apparaît proportionnel à Lm³ .

[Fixette2000]

dans la realité j'ai un nombre limité de cadres mais je peux en racheter si besoin...Effectivement j'ai pu observer qu'avec un stock limité le calcul est plus rapide

[Fixette2000]

Messieurs, (mesdames?),

je vous remercie pour votre participation généreuse, vous illustrez parfaitement l'idée que dans ce monde de brutes il existent encore des gens prêts à aider son prochain sans attendre en retour.
c'est beau.
vous m'avez fait gagner un temps précieux et je vous en suis très reconnaissant.

Je vais donc classer ce problème comme résolu.

Peace