Petit Probleme de logique

Bon on va s'y mettre ce week-end. C'est quelque chose que j'ai déjà fait. En
fait si j'ai bien compris, soit L une longueur, S un ensemble de rouleaux de
six pieds, D un ensemble de rouleaux de douze pieds.
Il faut commencer par calculer s, la longueur totale des rouleaux de six
pieds et d, la longueur totale des rouleaux de douze pieds : une simple
boucle suffit : c'est surtout pour simplifier le problème si L<s ou L>s+d.
C'est à dire si on peut tout faire en six pieds ou si le meilleur résultat
n'est pas de tout utiliser.
Pendant la boucle on vérifie si il n'y aurait pas un rouleau de S ou un de D
qui convienne :

Type t_Rouleaux
Longueur as integer
Nombre as Integer
End Type

S et D sont des tableaux de rouleaux
Dim S(1 to NbSorteRouleaux6Pieds) as t_Rouleaux
Dim D(1 to NbSorteRouleaux6Pieds) as t_Rouleaux
Dim I as integer, R as integer

Initialisation de S et D
LongueurTotaleS=0
R=0
For I=1 to NbSorteRouleaux6Pieds
If S(I).Longueur>L then
If I=1 then R=1
elseIf R=0 then R=I
elseIf S(I)<S(R) then R=I
End If
Else If R=0 then
LongueurTotaleS=LongueurTotaleS+S(I).Longueur*S(I).Nombre
End If
Next I

Donc si à la sortie de la boucle R est <>0 alors tu peux réaliser ta
commander avce un rouleau de numéro R. Tu peux même améliorer la gestion en
décomptant dans ce cas l'ensemble S d'une unité.
Si R=0, refaire la même chose avec D et LongueurTotaleD.
Et si LongueurTotaleS+LongueurTotaleD<L : on ne peut pas réaliser la
commande.
A bientôt pour la suite.


"Himselff" <info@dmsinc.ca> a écrit dans le message de
news:Z3Rhc.65496$Gp4.1642892@news20.bellglobal.com...

Bon voici ou jen suis avec cette algo de fou ,

Ce que je fais en premier lieu
-je regarde si dans mes rouleaux de pieds il ny aurait pas un qui fasse

le

travail,
-sinon je regarde la meme chose dans les 12 pieds,
-je regarde egalement dans le cas dune super grosse commande si je nai pas
sufiseament de 6 pieds ni de 12 pieds, est ce que jen aurais sufiseament

les

2 emsembles donc je prend tout les 6 pieds et je cherche quel est le
meilleur 12 pieds pour atteindre le total requis pour la commande,
-Si je nai qun 12 pieds qui est sufisant parfait tout fonctionne,
-Par contre quand jai besoin de plus dun 12 pieds ...

-Aussi je pourrais etre capable de completer ma commande avec plusieurs 6
pieds sauf que la encore meme probleme ,

Donc si qque a deja deveolper autour de cet algo jaurais besoin de petit
indice pour me demarer !

Merci beaucoup a lavance !

Fred
"Himselff" <info@dmsinc.ca> wrote in message
news:fCOhc.64205$Gp4.1596466@news20.bellglobal.com...
> Bonjour ,
>
> J'ai pris le temps de lire toute la documentation sur le probleme, je
> comprend tres bien le probleme et la solution, mais pour ce qui est de
> mettre tout sa en pratique cest une autre histoire,
>
> ce que je crois, cest que premiere des choses je devrais mettre tout les
> rouleaux dans une variable tableau en ordre croissant qui nous

permeterais

> detre capable de trier plus aisement par la suite, ensuite et bien

inserer

> lalgorythme qui va trouver le - les meilleurs rouleau !
>
> Jattend vos suggestions car je ne sais trop de quelle facon debuter !
>
> Merci
>
> Fred
> "le_troll" <le_trol@paris.fr> wrote in message
> news:#Cl7aWFKEHA.2012@TK2MSFTNGP11.phx.gbl...
> > La récursivité, je ne sais pas si c'est une bonne solution, car je

crois

> que
> > ça ne dépile pas contrairement à une boucle, alors faut voir si on ne
> risque
> > pas de sortir en "fin de pile", juste une petite réflexion
> supplémentaire...
> > Appeler une autre fonction, çan doit dépiler (end...), mais appeler sa
> > propre fonction, pas certain que ça dépile avant la fin du

traitement...

> > --
> > Merci, @+, bye, Joe
> > montmartre75@iFrance.com
> > ------------------------------------------
> > Avec une hache, celui qui tient le manche a toujours raison !
> > ------------------------------------------
> >
> >
> > "Patrice Henrio" <patrice.henrio.pasdepub@laposte.net> a écrit dans le
> > message de news: OGFq409JEHA.1040@TK2MSFTNGP10.phx.gbl...
> > > J'ai traité ce genre de problème sur ce forum il y a quelques temps

:

il
> > > fallait trouver la "meilleure" façon de réaliser une somme avec
> > différentes
> > > pièces. Ici il s'agit de réaliser de la meilleure façon une

longueur

> avec
> > > différents rouleaux de certaines longueurs chacun.
> > > On trouve l'explication de l'algorithme correspondant dans Structure
te
> > > interprétation des programmes informatiques de Abelson et Sussman
> (exemple
> > > du chapitre 1.2.2). (la 1ère édition en français est épuisée. La

2ème

> > > édition en anglais est disponible en ligne. [on peut télécharger son
> pdf],
> > > http://deptinfo.unice.fr/~roy/sicp.pdf)
> > > Il s'agit d'un algo récursif ce qui évite l'emploi de for next
imbriqué
> et
> > > est plus compréhensible.
> > > Avant de me lancer plus avant, que viennent faire les rouleaux de 6
> pieds
> > > dans ce pb ?
> > > En tout cas voici ce que ça donne avec les pièces de monnaies.
> > > Example: Counting change
> > > It takes only a bit of cleverness to come up with the iterative
> Fibonacci
> > > algorithm. In contrast, consider the
> > > following problem: How many different ways can we make change of $
1.00,
> > > given half-dollars, quarters,
> > > dimes, nickels, and pennies? More generally, can we write a

procedure

to
> > > compute the number of ways to
> > > change any given amount of money?
> > > This problem has a simple solution as a recursive procedure. Suppose
we
> > > think of the types of coins
> > > available as arranged in some order. Then the following relation
holds:
> > > The number of ways to change amount a using n kinds of coins equals
> > > the number of ways to change amount a using all but the first kind

of

> > coin,
> > > plus
> > > the number of ways to change amount a - d using all n kinds of

coins,

> > where
> > > d is the denomination
> > > of the first kind of coin.
> > > To see why this is true, observe that the ways to make change can be
> > divided
> > > into two groups: those that
> > > do not use any of the first kind of coin, and those that do.
Therefore,
> > the
> > > total number of ways to make
> > > change for some amount is equal to the number of ways to make change
for
> > the
> > > amount without using any
> > > of the first kind of coin, plus the number of ways to make change
> assuming
> > > that we do use the first kind of
> > > coin. But the latter number is equal to the number of ways to make
> change
> > > for the amount that remains
> > > after using a coin of the first kind.
> > > Thus, we can recursively reduce the problem of changing a given

amount

> to
> > > the problem of changing
> > > smaller amounts using fewer kinds of coins. Consider this reduction
rule
> > > carefully, and convince yourself
> > > that we can use it to describe an algorithm if we specify the
following
> > > degenerate cases:
> > > If a is exactly 0, we should count that as 1 way to make change.
> > > If a is less than 0, we should count that as 0 ways to make change.
> > > If n is 0, we should count that as 0 ways to make change.
> > > We can easily translate this description into a recursive procedure:
> > >
> > > (define (count-change amount)
> > > (cc amount 5))
> > >
> > > (define (cc amount kinds-of-coins)
> > > (cond ((= amount 0) 1)
> > > ((or (< amount 0) (= kinds-of-coins 0)) 0)
> > > (else (+ (cc amount
> > > (- kinds-of-coins 1))
> > > (cc (- amount
> > > (first-denomination kinds-of-coins))
> > > kinds-of-coins)))))
> > >
> > > (define (first-denomination kinds-of-coins)
> > > (cond ((= kinds-of-coins 1) 1)
> > > ((= kinds-of-coins 2) 5)
> > > ((= kinds-of-coins 3) 10)
> > > ((= kinds-of-coins 4) 25)
> > > ((= kinds-of-coins 5) 50)))
> > >
> > > (The first-denomination procedure takes as input the number of kinds
of
> > > coins available and
> > > returns the denomination of the first kind. Here we are thinking of
the
> > > coins as arranged in order from
> > > largest to smallest, but any order would do as well.) We can now
answer
> > our
> > > original question about
> > > changing a dollar:
> > > (count-change 100)
> > > Count-change generates a tree-recursive process with redundancies
> similar
> > to
> > > those in our first
> > > implementation of fib. (It will take quite a while for that 292 to

be

> > > computed.) On the other hand, it is
> > > not obvious how to design a better algorithm for computing the

result,

> and
> > > we leave this problem as a
> > > challenge. The observation that a tree-recursive process may be

highly

> > > inefficient but often easy to specify
> > > and understand has led people to propose that one could get the best
of
> > both
> > > worlds by designing a ``smart
> > > compiler'' that could transform tree-recursive procedures into more
> > > efficient procedures that compute the
> > > same result.
> > >
> > > Si tu n'es pas familiarisé avec le Lisp et les langages récursifs,

je

> peux
> > > t'aider dans ce projet.
> > > En gros on part de l'idée que si f est une fonction permettant
> d'atteindre
> > L
> > > avec des rouleaux d'un ensemble R, alors f atteint L-r1 avec le même
> > > ensemble R, dans lequel r1 est la longueur du premier rouleau

utilisé.

> > >
> > > J'ai l'impression que la première réponse avec problème NP évoquait
> plutôt
> > > celui du plus court chemin en passant par des points obligés. Le

fait

> > d'être
> > > en dimension deux change beaucoup le pb.
> > >
> > >
> > >
> > > "Himselff" <info@dmsinc.ca> a écrit dans le message de
> > > news:KNzhc.57140$Gp4.1302111@news20.bellglobal.com...
> > > > Wow merci du tuyau , je commence les recherches tout de suite ,

mais

> je
> > ne
> > > > mattendais pas du tout a avoir a coder un ci gros algo ,
> > > >
> > > > youou moi qui aime les maths en plus =)
> > > >
> > > > souhaiter moi bonne chance =)
> > > >
> > > > Fred
> > > >
> > > > "Jean-Marc" <nospamjean_marc_n2@yahoo.fr> wrote in message
> > > > news:4086c373$0$10948$a0ced6e1@news.skynet.be...
> > > > > "Himselff" <info@dmsinc.ca> a écrit dans le message de
> > > > > news:pGxhc.55193$Gp4.1267131@news20.bellglobal.com...
> > > > > > bonjour tout le monde,
> > > > > >
> > > > > > Je suis convaincu que le probleme est bien simple (encore une
> > fois ),
> > > > > voila
> > > > > > je m'explique
> > > > > >
> > > > > > Jai 2 categories de produits les rouleaux de 6 pieds et les
> > rouleaux
> > > de
> > > > > 12
> > > > > > pieds, pour realiser une commande ,
> > > > > >
> > > > > > Je dois selectionner selon le nombre de verge necessaire les
> > meilleurs
> > > > > > rouleaux pour avoir le moin de perte possible, Jarrive tres

bien

a
> > le
> > > > > faire
> > > > > > si par exemple jai assez de verge dans un rouleau , ou meme si
jai
> > > > besoin
> > > > > de
> > > > > > tout les 6 pieds et un seul 12 pieds (par ordre de priorite je
> dois
> > > > > prendre
> > > > > > tout les 6 pieds avant de songer a prendre les 12 pieds)
> > > > >
> > > > > Hello,
> > > > > ce problème n'est pas simple, il est même si compliqué que l'on

ne

> > sait
> > > > pas
> > > > > produire une solution optimale en un temps fini. (c'est un
problème
> NP
> > > > > complet en jargon mathématique).
> > > > >
> > > > > Ton problème est proche d'un problème générique connu sous le

nom

de
> > > > > "programme du sac à dos". Il existe des méthodes de résolution

qui

> > > > arrivent
> > > > > à une solution "la plus optimale possible" en un temps fini.
> > > > >
> > > > > Tu trouveras une description de ce genre d'algorithme sur google
en
> > > > > cherchant "knapsack problem" ou encore "programmation linéaire"

ou

> > > encore
> > > > > "problème du sac à dos".
> > > > >
> > > > > Les explications et les justifications mathématiques sont un peu
> > (très)
> > > > > ardues, mais on trouve assez aisément des implémentations de
> > > l'algorithme,
> > > > > en pseudo code ou en C, aisées à traduire en VB.
> > > > >
> > > > > Jean-Marc
> > > > >
> > > > >
> > > >
> > > >
> > >
> > >
> >
> >
>
>

Merci Beaucoup Patrice pour le coup de main ,

J'ai realiser qu'il yavait peut etre une autre solution pour determiner
quel(s) rouleaux etait meilleur tu me dira ce que tu en pense,

Si je calcule la valeur total pour tout les rouleaux de 6 pieds ensemble sa
me permet de voir si oui ou non jen ai sufiseament , meme chose pour les 12
pieds, tu sera surement daccord pour dire que cest deux conditions sont
essentiel, je dois egalement regarder dans la negative des 2 premieres si en
combinant 6 et 12 pieds je ne ferais pas le compte, dans la negative parfait
on arrete tout et on passe a un autre numero,

Dans laffirmative de lune ou lautre des conditions si je prend tout les 6
pieds et les 12 pieds et je les met dans un tableau comme dans ton exemple ,
sauf quen ajoutant une colonne BOOLEAN qui me permeterais de dire TRUE il
est deja utiliser et FALSE tu peux continuer a le comparer,

En comparant chaque rouleaux avec la valeur a atteindre sa me permet de
trouver mon manque a gagner , ce qui me permet de trouver a chaque LOOP quel
rouleau est le meilleur et lui mettre TRUE dans son index et Incrementer ma
valeur atteinte ce qui me donnerais une formule du genre :
valeur a atteindre = valeur a atteindre - valeur du meilleur rouleau
donc dans le loop suivante il passe par dessus le rouleau que je viens de
mettre a TRUE et regarde le manque a gagner des autre rouleaux et ainsi de
suite jusqua ce que ma valeur atteinte soit >= a valeur a atteindre du
depart !

Dis moi ce que tu en pense, je crois que cette methode est beaucoup plus
simple que lautre , jai deja rempli les deux tableaux , calculer le total de
tout les 6 pieds et de tout les 12 pieds , jai aussi determiner mon manque a
gagner , ainsi que la quantite totale de 6 pieds et de 12 pieds pour les
LOOP,

Jattend de tes nouvelles , entre temps je vais continuer de progresser vers
cette methode et ten redonner des nouvelles , si tu veux que je post mon
code dis la moi !

Merci

Fred

"Patrice Henrio" <patrice.henrio.pasdepub@laposte.net> wrote in message
news:#Eq6ltIKEHA.2880@TK2MSFTNGP10.phx.gbl...

Bon on va s'y mettre ce week-end. C'est quelque chose que j'ai déjà fait.

En

fait si j'ai bien compris, soit L une longueur, S un ensemble de rouleaux

de

six pieds, D un ensemble de rouleaux de douze pieds.
Il faut commencer par calculer s, la longueur totale des rouleaux de six
pieds et d, la longueur totale des rouleaux de douze pieds : une simple
boucle suffit : c'est surtout pour simplifier le problème si L<s ou L>s+d.
C'est à dire si on peut tout faire en six pieds ou si le meilleur résultat
n'est pas de tout utiliser.
Pendant la boucle on vérifie si il n'y aurait pas un rouleau de S ou un de

D

qui convienne :

Type t_Rouleaux
Longueur as integer
Nombre as Integer
End Type

S et D sont des tableaux de rouleaux
Dim S(1 to NbSorteRouleaux6Pieds) as t_Rouleaux
Dim D(1 to NbSorteRouleaux6Pieds) as t_Rouleaux
Dim I as integer, R as integer

Initialisation de S et D
LongueurTotaleS=0
R=0
For I=1 to NbSorteRouleaux6Pieds
If S(I).Longueur>L then
If I=1 then R=1
elseIf R=0 then R=I
elseIf S(I)<S(R) then R=I
End If
Else If R=0 then
LongueurTotaleS=LongueurTotaleS+S(I).Longueur*S(I).Nombre
End If
Next I

Donc si à la sortie de la boucle R est <>0 alors tu peux réaliser ta
commander avce un rouleau de numéro R. Tu peux même améliorer la gestion

en

décomptant dans ce cas l'ensemble S d'une unité.
Si R=0, refaire la même chose avec D et LongueurTotaleD.
Et si LongueurTotaleS+LongueurTotaleD<L : on ne peut pas réaliser la
commande.
A bientôt pour la suite.


"Himselff" <info@dmsinc.ca> a écrit dans le message de
news:Z3Rhc.65496$Gp4.1642892@news20.bellglobal.com...
> Bon voici ou jen suis avec cette algo de fou ,
>
> Ce que je fais en premier lieu
> -je regarde si dans mes rouleaux de pieds il ny aurait pas un qui fasse
le
> travail,
> -sinon je regarde la meme chose dans les 12 pieds,
> -je regarde egalement dans le cas dune super grosse commande si je nai

pas

> sufiseament de 6 pieds ni de 12 pieds, est ce que jen aurais sufiseament
les
> 2 emsembles donc je prend tout les 6 pieds et je cherche quel est le
> meilleur 12 pieds pour atteindre le total requis pour la commande,
> -Si je nai qun 12 pieds qui est sufisant parfait tout fonctionne,
> -Par contre quand jai besoin de plus dun 12 pieds ...
>
> -Aussi je pourrais etre capable de completer ma commande avec plusieurs

6

> pieds sauf que la encore meme probleme ,
>
> Donc si qque a deja deveolper autour de cet algo jaurais besoin de petit
> indice pour me demarer !
>
> Merci beaucoup a lavance !
>
> Fred
> "Himselff" <info@dmsinc.ca> wrote in message
> news:fCOhc.64205$Gp4.1596466@news20.bellglobal.com...
> > Bonjour ,
> >
> > J'ai pris le temps de lire toute la documentation sur le probleme, je
> > comprend tres bien le probleme et la solution, mais pour ce qui est de
> > mettre tout sa en pratique cest une autre histoire,
> >
> > ce que je crois, cest que premiere des choses je devrais mettre tout

les

> > rouleaux dans une variable tableau en ordre croissant qui nous
permeterais
> > detre capable de trier plus aisement par la suite, ensuite et bien
inserer
> > lalgorythme qui va trouver le - les meilleurs rouleau !
> >
> > Jattend vos suggestions car je ne sais trop de quelle facon debuter !
> >
> > Merci
> >
> > Fred
> > "le_troll" <le_trol@paris.fr> wrote in message
> > news:#Cl7aWFKEHA.2012@TK2MSFTNGP11.phx.gbl...
> > > La récursivité, je ne sais pas si c'est une bonne solution, car je
crois
> > que
> > > ça ne dépile pas contrairement à une boucle, alors faut voir si on

ne

> > risque
> > > pas de sortir en "fin de pile", juste une petite réflexion
> > supplémentaire...
> > > Appeler une autre fonction, çan doit dépiler (end...), mais appeler

sa

> > > propre fonction, pas certain que ça dépile avant la fin du
traitement...
> > > --
> > > Merci, @+, bye, Joe
> > > montmartre75@iFrance.com
> > > ------------------------------------------
> > > Avec une hache, celui qui tient le manche a toujours raison !
> > > ------------------------------------------
> > >
> > >
> > > "Patrice Henrio" <patrice.henrio.pasdepub@laposte.net> a écrit dans

le

> > > message de news: OGFq409JEHA.1040@TK2MSFTNGP10.phx.gbl...
> > > > J'ai traité ce genre de problème sur ce forum il y a quelques

temps

:
> il
> > > > fallait trouver la "meilleure" façon de réaliser une somme avec
> > > différentes
> > > > pièces. Ici il s'agit de réaliser de la meilleure façon une
longueur
> > avec
> > > > différents rouleaux de certaines longueurs chacun.
> > > > On trouve l'explication de l'algorithme correspondant dans

Structure

> te
> > > > interprétation des programmes informatiques de Abelson et Sussman
> > (exemple
> > > > du chapitre 1.2.2). (la 1ère édition en français est épuisée. La
2ème
> > > > édition en anglais est disponible en ligne. [on peut télécharger

son

> > pdf],
> > > > http://deptinfo.unice.fr/~roy/sicp.pdf)
> > > > Il s'agit d'un algo récursif ce qui évite l'emploi de for next
> imbriqué
> > et
> > > > est plus compréhensible.
> > > > Avant de me lancer plus avant, que viennent faire les rouleaux de

6

> > pieds
> > > > dans ce pb ?
> > > > En tout cas voici ce que ça donne avec les pièces de monnaies.
> > > > Example: Counting change
> > > > It takes only a bit of cleverness to come up with the iterative
> > Fibonacci
> > > > algorithm. In contrast, consider the
> > > > following problem: How many different ways can we make change of $
> 1.00,
> > > > given half-dollars, quarters,
> > > > dimes, nickels, and pennies? More generally, can we write a
procedure
> to
> > > > compute the number of ways to
> > > > change any given amount of money?
> > > > This problem has a simple solution as a recursive procedure.

Suppose

> we
> > > > think of the types of coins
> > > > available as arranged in some order. Then the following relation
> holds:
> > > > The number of ways to change amount a using n kinds of coins

equals

> > > > the number of ways to change amount a using all but the first kind
of
> > > coin,
> > > > plus
> > > > the number of ways to change amount a - d using all n kinds of
coins,
> > > where
> > > > d is the denomination
> > > > of the first kind of coin.
> > > > To see why this is true, observe that the ways to make change can

be

> > > divided
> > > > into two groups: those that
> > > > do not use any of the first kind of coin, and those that do.
> Therefore,
> > > the
> > > > total number of ways to make
> > > > change for some amount is equal to the number of ways to make

change

> for
> > > the
> > > > amount without using any
> > > > of the first kind of coin, plus the number of ways to make change
> > assuming
> > > > that we do use the first kind of
> > > > coin. But the latter number is equal to the number of ways to make
> > change
> > > > for the amount that remains
> > > > after using a coin of the first kind.
> > > > Thus, we can recursively reduce the problem of changing a given
amount
> > to
> > > > the problem of changing
> > > > smaller amounts using fewer kinds of coins. Consider this

reduction

> rule
> > > > carefully, and convince yourself
> > > > that we can use it to describe an algorithm if we specify the
> following
> > > > degenerate cases:
> > > > If a is exactly 0, we should count that as 1 way to make change.
> > > > If a is less than 0, we should count that as 0 ways to make

change.

> > > > If n is 0, we should count that as 0 ways to make change.
> > > > We can easily translate this description into a recursive

procedure:

> > > >
> > > > (define (count-change amount)
> > > > (cc amount 5))
> > > >
> > > > (define (cc amount kinds-of-coins)
> > > > (cond ((= amount 0) 1)
> > > > ((or (< amount 0) (= kinds-of-coins 0)) 0)
> > > > (else (+ (cc amount
> > > > (- kinds-of-coins 1))
> > > > (cc (- amount
> > > > (first-denomination kinds-of-coins))
> > > > kinds-of-coins)))))
> > > >
> > > > (define (first-denomination kinds-of-coins)
> > > > (cond ((= kinds-of-coins 1) 1)
> > > > ((= kinds-of-coins 2) 5)
> > > > ((= kinds-of-coins 3) 10)
> > > > ((= kinds-of-coins 4) 25)
> > > > ((= kinds-of-coins 5) 50)))
> > > >
> > > > (The first-denomination procedure takes as input the number of

kinds

> of
> > > > coins available and
> > > > returns the denomination of the first kind. Here we are thinking

of

> the
> > > > coins as arranged in order from
> > > > largest to smallest, but any order would do as well.) We can now
> answer
> > > our
> > > > original question about
> > > > changing a dollar:
> > > > (count-change 100)
> > > > Count-change generates a tree-recursive process with redundancies
> > similar
> > > to
> > > > those in our first
> > > > implementation of fib. (It will take quite a while for that 292 to
be
> > > > computed.) On the other hand, it is
> > > > not obvious how to design a better algorithm for computing the
result,
> > and
> > > > we leave this problem as a
> > > > challenge. The observation that a tree-recursive process may be
highly
> > > > inefficient but often easy to specify
> > > > and understand has led people to propose that one could get the

best

> of
> > > both
> > > > worlds by designing a ``smart
> > > > compiler'' that could transform tree-recursive procedures into

more

> > > > efficient procedures that compute the
> > > > same result.
> > > >
> > > > Si tu n'es pas familiarisé avec le Lisp et les langages récursifs,
je
> > peux
> > > > t'aider dans ce projet.
> > > > En gros on part de l'idée que si f est une fonction permettant
> > d'atteindre
> > > L
> > > > avec des rouleaux d'un ensemble R, alors f atteint L-r1 avec le

même

> > > > ensemble R, dans lequel r1 est la longueur du premier rouleau
utilisé.
> > > >
> > > > J'ai l'impression que la première réponse avec problème NP

évoquait

> > plutôt
> > > > celui du plus court chemin en passant par des points obligés. Le
fait
> > > d'être
> > > > en dimension deux change beaucoup le pb.
> > > >
> > > >
> > > >
> > > > "Himselff" <info@dmsinc.ca> a écrit dans le message de
> > > > news:KNzhc.57140$Gp4.1302111@news20.bellglobal.com...
> > > > > Wow merci du tuyau , je commence les recherches tout de suite ,
mais
> > je
> > > ne
> > > > > mattendais pas du tout a avoir a coder un ci gros algo ,
> > > > >
> > > > > youou moi qui aime les maths en plus =)
> > > > >
> > > > > souhaiter moi bonne chance =)
> > > > >
> > > > > Fred
> > > > >
> > > > > "Jean-Marc" <nospamjean_marc_n2@yahoo.fr> wrote in message
> > > > > news:4086c373$0$10948$a0ced6e1@news.skynet.be...
> > > > > > "Himselff" <info@dmsinc.ca> a écrit dans le message de
> > > > > > news:pGxhc.55193$Gp4.1267131@news20.bellglobal.com...
> > > > > > > bonjour tout le monde,
> > > > > > >
> > > > > > > Je suis convaincu que le probleme est bien simple (encore

une

> > > fois ),
> > > > > > voila
> > > > > > > je m'explique
> > > > > > >
> > > > > > > Jai 2 categories de produits les rouleaux de 6 pieds et les
> > > rouleaux
> > > > de
> > > > > > 12
> > > > > > > pieds, pour realiser une commande ,
> > > > > > >
> > > > > > > Je dois selectionner selon le nombre de verge necessaire les
> > > meilleurs
> > > > > > > rouleaux pour avoir le moin de perte possible, Jarrive tres
bien
> a
> > > le
> > > > > > faire
> > > > > > > si par exemple jai assez de verge dans un rouleau , ou meme

si

> jai
> > > > > besoin
> > > > > > de
> > > > > > > tout les 6 pieds et un seul 12 pieds (par ordre de priorite

je

> > dois
> > > > > > prendre
> > > > > > > tout les 6 pieds avant de songer a prendre les 12 pieds)
> > > > > >
> > > > > > Hello,
> > > > > > ce problème n'est pas simple, il est même si compliqué que

l'on

ne
> > > sait
> > > > > pas
> > > > > > produire une solution optimale en un temps fini. (c'est un
> problème
> > NP
> > > > > > complet en jargon mathématique).
> > > > > >
> > > > > > Ton problème est proche d'un problème générique connu sous le
nom
> de
> > > > > > "programme du sac à dos". Il existe des méthodes de résolution
qui
> > > > > arrivent
> > > > > > à une solution "la plus optimale possible" en un temps fini.
> > > > > >
> > > > > > Tu trouveras une description de ce genre d'algorithme sur

google

> en
> > > > > > cherchant "knapsack problem" ou encore "programmation

linéaire"

ou
> > > > encore
> > > > > > "problème du sac à dos".
> > > > > >
> > > > > > Les explications et les justifications mathématiques sont un

peu

> > > (très)
> > > > > > ardues, mais on trouve assez aisément des implémentations de
> > > > l'algorithme,
> > > > > > en pseudo code ou en C, aisées à traduire en VB.
> > > > > >
> > > > > > Jean-Marc
> > > > > >
> > > > > >
> > > > >
> > > > >
> > > >
> > > >
> > >
> > >
> >
> >
>
>

Effectivement cela me parait une bonne méthode.
Cependant peux-tu préciser quelque points
peux-tu utiliser plusieurs fois le même type de rouleau (je te rappelle que
d'après ce que j'ai compris, un type de rouleau c'est une largeur (6 ou 12)
et une longueur) ?
D'après l'algo que tu développes ensuite j'ai l'impression que non.
Cependant il n'est pas évident que la meilleure méthode pour obtenir un
total consiste à prendre à chaque fois le nombre le plus proche :
Je dispose de 3,4,5 et 10 : pour faire 12 on voit qu'il faut utiliser 3+4+5.
Ton algo dirait qu'il faut utiliser 10+3.

Si l'opération est réalisable avec des rouleaux de 6 (ou de 12), faut-il
regarder s'il y aurait moins de perte en mixant les deux catégories ?
Pour ta troisième colonne, cela revient d'après ce que je comprends à
transformer en itératif une procédure éminemment récursive. On gagne en
espace mémoire et en temps mais on perd en compréhension et en facilité de
mise en ouvre.

Pour terminer, contrairement à ce qui était affirmé dans un mail précédent,
la récursivité dépile correctement en fin de course.

Exemple

Function Factoriel(N as integer) as integer
If N=1 then
Factoriel=1
else
Factoriel=N*Factoriel(N-1)
End If
End Function


Donc quand on appelle Factoriel(3)
Empilage des paramètres de retour
N(1er appel) vaut 3
N diff de 1
Appel de Factoriel(2)
Empilage des paramètres de retour
N(2ème appel) vaut 2
N diff de 1
Appel de Factoriel(1)
Empilage des paramètres de retour
N(3ème appel) vaut 1
N=1
Valeur de retour(3ème appel) vaut 1
Dépilage des valeurs
Valeur de retour(2ème appel) vaut 2*Valeur de retour(3ème appel)
Valeur de retour(2ème appel) vaut 2
Dépilage des valeurs
Valeur de retour(1er appel) vaut 3*Valeur de retour(2ème appel)
Valeur de retour(1er appel) vaut 6
Factoriel(3) vaut 6

A bientôt.

"Himselff" <info@dmsinc.ca> a écrit dans le message de
news:CLVhc.68847$Gp4.1712083@news20.bellglobal.com...

Merci Beaucoup Patrice pour le coup de main ,

J'ai realiser qu'il yavait peut etre une autre solution pour determiner
quel(s) rouleaux etait meilleur tu me dira ce que tu en pense,

Si je calcule la valeur total pour tout les rouleaux de 6 pieds ensemble

sa

me permet de voir si oui ou non jen ai sufiseament , meme chose pour les

12

pieds, tu sera surement daccord pour dire que cest deux conditions sont
essentiel, je dois egalement regarder dans la negative des 2 premieres si

en

combinant 6 et 12 pieds je ne ferais pas le compte, dans la negative

parfait

on arrete tout et on passe a un autre numero,

Dans laffirmative de lune ou lautre des conditions si je prend tout les 6
pieds et les 12 pieds et je les met dans un tableau comme dans ton exemple

,

sauf quen ajoutant une colonne BOOLEAN qui me permeterais de dire TRUE il
est deja utiliser et FALSE tu peux continuer a le comparer,

En comparant chaque rouleaux avec la valeur a atteindre sa me permet de
trouver mon manque a gagner , ce qui me permet de trouver a chaque LOOP

quel

rouleau est le meilleur et lui mettre TRUE dans son index et Incrementer

ma

valeur atteinte ce qui me donnerais une formule du genre :
valeur a atteindre = valeur a atteindre - valeur du meilleur rouleau
donc dans le loop suivante il passe par dessus le rouleau que je viens de
mettre a TRUE et regarde le manque a gagner des autre rouleaux et ainsi de
suite jusqua ce que ma valeur atteinte soit >= a valeur a atteindre du
depart !

Dis moi ce que tu en pense, je crois que cette methode est beaucoup plus
simple que lautre , jai deja rempli les deux tableaux , calculer le total

de

tout les 6 pieds et de tout les 12 pieds , jai aussi determiner mon manque

a

gagner , ainsi que la quantite totale de 6 pieds et de 12 pieds pour les
LOOP,

Jattend de tes nouvelles , entre temps je vais continuer de progresser

vers

cette methode et ten redonner des nouvelles , si tu veux que je post mon
code dis la moi !

Merci

Fred

"Patrice Henrio" <patrice.henrio.pasdepub@laposte.net> wrote in message
news:#Eq6ltIKEHA.2880@TK2MSFTNGP10.phx.gbl...
> Bon on va s'y mettre ce week-end. C'est quelque chose que j'ai déjà

fait.

En
> fait si j'ai bien compris, soit L une longueur, S un ensemble de

rouleaux

de
> six pieds, D un ensemble de rouleaux de douze pieds.
> Il faut commencer par calculer s, la longueur totale des rouleaux de six
> pieds et d, la longueur totale des rouleaux de douze pieds : une simple
> boucle suffit : c'est surtout pour simplifier le problème si L<s ou

L>s+d.

> C'est à dire si on peut tout faire en six pieds ou si le meilleur

résultat

> n'est pas de tout utiliser.
> Pendant la boucle on vérifie si il n'y aurait pas un rouleau de S ou un

de

D
> qui convienne :
>
> Type t_Rouleaux
> Longueur as integer
> Nombre as Integer
> End Type
>
> S et D sont des tableaux de rouleaux
> Dim S(1 to NbSorteRouleaux6Pieds) as t_Rouleaux
> Dim D(1 to NbSorteRouleaux6Pieds) as t_Rouleaux
> Dim I as integer, R as integer
>
> Initialisation de S et D
> LongueurTotaleS=0
> R=0
> For I=1 to NbSorteRouleaux6Pieds
> If S(I).Longueur>L then
> If I=1 then R=1
> elseIf R=0 then R=I
> elseIf S(I)<S(R) then R=I
> End If
> Else If R=0 then
> LongueurTotaleS=LongueurTotaleS+S(I).Longueur*S(I).Nombre
> End If
> Next I
>
> Donc si à la sortie de la boucle R est <>0 alors tu peux réaliser ta
> commander avce un rouleau de numéro R. Tu peux même améliorer la gestion
en
> décomptant dans ce cas l'ensemble S d'une unité.
> Si R=0, refaire la même chose avec D et LongueurTotaleD.
> Et si LongueurTotaleS+LongueurTotaleD<L : on ne peut pas réaliser la
> commande.
> A bientôt pour la suite.
>
>
> "Himselff" <info@dmsinc.ca> a écrit dans le message de
> news:Z3Rhc.65496$Gp4.1642892@news20.bellglobal.com...
> > Bon voici ou jen suis avec cette algo de fou ,
> >
> > Ce que je fais en premier lieu
> > -je regarde si dans mes rouleaux de pieds il ny aurait pas un qui

fasse

> le
> > travail,
> > -sinon je regarde la meme chose dans les 12 pieds,
> > -je regarde egalement dans le cas dune super grosse commande si je nai
pas
> > sufiseament de 6 pieds ni de 12 pieds, est ce que jen aurais

sufiseament

> les
> > 2 emsembles donc je prend tout les 6 pieds et je cherche quel est le
> > meilleur 12 pieds pour atteindre le total requis pour la commande,
> > -Si je nai qun 12 pieds qui est sufisant parfait tout fonctionne,
> > -Par contre quand jai besoin de plus dun 12 pieds ...
> >
> > -Aussi je pourrais etre capable de completer ma commande avec

plusieurs

6
> > pieds sauf que la encore meme probleme ,
> >
> > Donc si qque a deja deveolper autour de cet algo jaurais besoin de

petit

> > indice pour me demarer !
> >
> > Merci beaucoup a lavance !
> >
> > Fred
> > "Himselff" <info@dmsinc.ca> wrote in message
> > news:fCOhc.64205$Gp4.1596466@news20.bellglobal.com...
> > > Bonjour ,
> > >
> > > J'ai pris le temps de lire toute la documentation sur le probleme,

je

> > > comprend tres bien le probleme et la solution, mais pour ce qui est

de

> > > mettre tout sa en pratique cest une autre histoire,
> > >
> > > ce que je crois, cest que premiere des choses je devrais mettre tout
les
> > > rouleaux dans une variable tableau en ordre croissant qui nous
> permeterais
> > > detre capable de trier plus aisement par la suite, ensuite et bien
> inserer
> > > lalgorythme qui va trouver le - les meilleurs rouleau !
> > >
> > > Jattend vos suggestions car je ne sais trop de quelle facon debuter

!

> > >
> > > Merci
> > >
> > > Fred
> > > "le_troll" <le_trol@paris.fr> wrote in message
> > > news:#Cl7aWFKEHA.2012@TK2MSFTNGP11.phx.gbl...
> > > > La récursivité, je ne sais pas si c'est une bonne solution, car je
> crois
> > > que
> > > > ça ne dépile pas contrairement à une boucle, alors faut voir si on
ne
> > > risque
> > > > pas de sortir en "fin de pile", juste une petite réflexion
> > > supplémentaire...
> > > > Appeler une autre fonction, çan doit dépiler (end...), mais

appeler

sa
> > > > propre fonction, pas certain que ça dépile avant la fin du
> traitement...
> > > > --
> > > > Merci, @+, bye, Joe
> > > > montmartre75@iFrance.com
> > > > ------------------------------------------
> > > > Avec une hache, celui qui tient le manche a toujours raison !
> > > > ------------------------------------------
> > > >
> > > >
> > > > "Patrice Henrio" <patrice.henrio.pasdepub@laposte.net> a écrit

dans

le
> > > > message de news: OGFq409JEHA.1040@TK2MSFTNGP10.phx.gbl...
> > > > > J'ai traité ce genre de problème sur ce forum il y a quelques
temps
> :
> > il
> > > > > fallait trouver la "meilleure" façon de réaliser une somme avec
> > > > différentes
> > > > > pièces. Ici il s'agit de réaliser de la meilleure façon une
> longueur
> > > avec
> > > > > différents rouleaux de certaines longueurs chacun.
> > > > > On trouve l'explication de l'algorithme correspondant dans
Structure
> > te
> > > > > interprétation des programmes informatiques de Abelson et

Sussman

> > > (exemple
> > > > > du chapitre 1.2.2). (la 1ère édition en français est épuisée. La
> 2ème
> > > > > édition en anglais est disponible en ligne. [on peut télécharger
son
> > > pdf],
> > > > > http://deptinfo.unice.fr/~roy/sicp.pdf)
> > > > > Il s'agit d'un algo récursif ce qui évite l'emploi de for next
> > imbriqué
> > > et
> > > > > est plus compréhensible.
> > > > > Avant de me lancer plus avant, que viennent faire les rouleaux

de

6
> > > pieds
> > > > > dans ce pb ?
> > > > > En tout cas voici ce que ça donne avec les pièces de monnaies.
> > > > > Example: Counting change
> > > > > It takes only a bit of cleverness to come up with the iterative
> > > Fibonacci
> > > > > algorithm. In contrast, consider the
> > > > > following problem: How many different ways can we make change of

$

> > 1.00,
> > > > > given half-dollars, quarters,
> > > > > dimes, nickels, and pennies? More generally, can we write a
> procedure
> > to
> > > > > compute the number of ways to
> > > > > change any given amount of money?
> > > > > This problem has a simple solution as a recursive procedure.
Suppose
> > we
> > > > > think of the types of coins
> > > > > available as arranged in some order. Then the following relation
> > holds:
> > > > > The number of ways to change amount a using n kinds of coins
equals
> > > > > the number of ways to change amount a using all but the first

kind

> of
> > > > coin,
> > > > > plus
> > > > > the number of ways to change amount a - d using all n kinds of
> coins,
> > > > where
> > > > > d is the denomination
> > > > > of the first kind of coin.
> > > > > To see why this is true, observe that the ways to make change

can

be
> > > > divided
> > > > > into two groups: those that
> > > > > do not use any of the first kind of coin, and those that do.
> > Therefore,
> > > > the
> > > > > total number of ways to make
> > > > > change for some amount is equal to the number of ways to make
change
> > for
> > > > the
> > > > > amount without using any
> > > > > of the first kind of coin, plus the number of ways to make

change

> > > assuming
> > > > > that we do use the first kind of
> > > > > coin. But the latter number is equal to the number of ways to

make

> > > change
> > > > > for the amount that remains
> > > > > after using a coin of the first kind.
> > > > > Thus, we can recursively reduce the problem of changing a given
> amount
> > > to
> > > > > the problem of changing
> > > > > smaller amounts using fewer kinds of coins. Consider this
reduction
> > rule
> > > > > carefully, and convince yourself
> > > > > that we can use it to describe an algorithm if we specify the
> > following
> > > > > degenerate cases:
> > > > > If a is exactly 0, we should count that as 1 way to make change.
> > > > > If a is less than 0, we should count that as 0 ways to make
change.
> > > > > If n is 0, we should count that as 0 ways to make change.
> > > > > We can easily translate this description into a recursive
procedure:
> > > > >
> > > > > (define (count-change amount)
> > > > > (cc amount 5))
> > > > >
> > > > > (define (cc amount kinds-of-coins)
> > > > > (cond ((= amount 0) 1)
> > > > > ((or (< amount 0) (= kinds-of-coins 0)) 0)
> > > > > (else (+ (cc amount
> > > > > (- kinds-of-coins 1))
> > > > > (cc (- amount
> > > > > (first-denomination kinds-of-coins))
> > > > > kinds-of-coins)))))
> > > > >
> > > > > (define (first-denomination kinds-of-coins)
> > > > > (cond ((= kinds-of-coins 1) 1)
> > > > > ((= kinds-of-coins 2) 5)
> > > > > ((= kinds-of-coins 3) 10)
> > > > > ((= kinds-of-coins 4) 25)
> > > > > ((= kinds-of-coins 5) 50)))
> > > > >
> > > > > (The first-denomination procedure takes as input the number of
kinds
> > of
> > > > > coins available and
> > > > > returns the denomination of the first kind. Here we are thinking
of
> > the
> > > > > coins as arranged in order from
> > > > > largest to smallest, but any order would do as well.) We can now
> > answer
> > > > our
> > > > > original question about
> > > > > changing a dollar:
> > > > > (count-change 100)
> > > > > Count-change generates a tree-recursive process with

redundancies

> > > similar
> > > > to
> > > > > those in our first
> > > > > implementation of fib. (It will take quite a while for that 292

to

> be
> > > > > computed.) On the other hand, it is
> > > > > not obvious how to design a better algorithm for computing the
> result,
> > > and
> > > > > we leave this problem as a
> > > > > challenge. The observation that a tree-recursive process may be
> highly
> > > > > inefficient but often easy to specify
> > > > > and understand has led people to propose that one could get the
best
> > of
> > > > both
> > > > > worlds by designing a ``smart
> > > > > compiler'' that could transform tree-recursive procedures into
more
> > > > > efficient procedures that compute the
> > > > > same result.
> > > > >
> > > > > Si tu n'es pas familiarisé avec le Lisp et les langages

récursifs,

> je
> > > peux
> > > > > t'aider dans ce projet.
> > > > > En gros on part de l'idée que si f est une fonction permettant
> > > d'atteindre
> > > > L
> > > > > avec des rouleaux d'un ensemble R, alors f atteint L-r1 avec le
même
> > > > > ensemble R, dans lequel r1 est la longueur du premier rouleau
> utilisé.
> > > > >
> > > > > J'ai l'impression que la première réponse avec problème NP
évoquait
> > > plutôt
> > > > > celui du plus court chemin en passant par des points obligés. Le
> fait
> > > > d'être
> > > > > en dimension deux change beaucoup le pb.
> > > > >
> > > > >
> > > > >
> > > > > "Himselff" <info@dmsinc.ca> a écrit dans le message de
> > > > > news:KNzhc.57140$Gp4.1302111@news20.bellglobal.com...
> > > > > > Wow merci du tuyau , je commence les recherches tout de suite

,

> mais
> > > je
> > > > ne
> > > > > > mattendais pas du tout a avoir a coder un ci gros algo ,
> > > > > >
> > > > > > youou moi qui aime les maths en plus =)
> > > > > >
> > > > > > souhaiter moi bonne chance =)
> > > > > >
> > > > > > Fred
> > > > > >
> > > > > > "Jean-Marc" <nospamjean_marc_n2@yahoo.fr> wrote in message
> > > > > > news:4086c373$0$10948$a0ced6e1@news.skynet.be...
> > > > > > > "Himselff" <info@dmsinc.ca> a écrit dans le message de
> > > > > > > news:pGxhc.55193$Gp4.1267131@news20.bellglobal.com...
> > > > > > > > bonjour tout le monde,
> > > > > > > >
> > > > > > > > Je suis convaincu que le probleme est bien simple (encore
une
> > > > fois ),
> > > > > > > voila
> > > > > > > > je m'explique
> > > > > > > >
> > > > > > > > Jai 2 categories de produits les rouleaux de 6 pieds et

les

> > > > rouleaux
> > > > > de
> > > > > > > 12
> > > > > > > > pieds, pour realiser une commande ,
> > > > > > > >
> > > > > > > > Je dois selectionner selon le nombre de verge necessaire

les

> > > > meilleurs
> > > > > > > > rouleaux pour avoir le moin de perte possible, Jarrive

tres

> bien
> > a
> > > > le
> > > > > > > faire
> > > > > > > > si par exemple jai assez de verge dans un rouleau , ou

meme

si
> > jai
> > > > > > besoin
> > > > > > > de
> > > > > > > > tout les 6 pieds et un seul 12 pieds (par ordre de

priorite

je
> > > dois
> > > > > > > prendre
> > > > > > > > tout les 6 pieds avant de songer a prendre les 12 pieds)
> > > > > > >
> > > > > > > Hello,
> > > > > > > ce problème n'est pas simple, il est même si compliqué que
l'on
> ne
> > > > sait
> > > > > > pas
> > > > > > > produire une solution optimale en un temps fini. (c'est un
> > problème
> > > NP
> > > > > > > complet en jargon mathématique).
> > > > > > >
> > > > > > > Ton problème est proche d'un problème générique connu sous

le

> nom
> > de
> > > > > > > "programme du sac à dos". Il existe des méthodes de

résolution

> qui
> > > > > > arrivent
> > > > > > > à une solution "la plus optimale possible" en un temps fini.
> > > > > > >
> > > > > > > Tu trouveras une description de ce genre d'algorithme sur
google
> > en
> > > > > > > cherchant "knapsack problem" ou encore "programmation
linéaire"
> ou
> > > > > encore
> > > > > > > "problème du sac à dos".
> > > > > > >
> > > > > > > Les explications et les justifications mathématiques sont un
peu
> > > > (très)
> > > > > > > ardues, mais on trouve assez aisément des implémentations de
> > > > > l'algorithme,
> > > > > > > en pseudo code ou en C, aisées à traduire en VB.
> > > > > > >
> > > > > > > Jean-Marc
> > > > > > >
> > > > > > >
> > > > > >
> > > > > >
> > > > >
> > > > >
> > > >
> > > >
> > >
> > >
> >
> >
>
>

Merci encore Patrice de tes precieux conseils ,

regarde plus bas pour les réponses à tes questions, j'attend de tes
nouvelles je ne veux pas me lancer dans d'interminable suposition quand je
ne suis pas sure d'avoir la meilleur façon !

Merci

Fred

"Patrice Henrio" <patrice.henrio.pasdepub@laposte.net> wrote in message
news:OxeVFcVKEHA.3216@tk2msftngp13.phx.gbl...

Effectivement cela me parait une bonne méthode.
Cependant peux-tu préciser quelque points
peux-tu utiliser plusieurs fois le même type de rouleau (je te rappelle

que

d'après ce que j'ai compris, un type de rouleau c'est une largeur (6 ou

12)

et une longueur) ?

Absolument classer dans 2 tables diferentes dans ma base de données qui par
la suite sont trier en ordre croissant et mis dans une variable tableau
diferente,
Cest bien evident que jai dautres valeures qui s'attachent à mes rouleaux
comme la clef , la location dans l'usine, le numéro de patron etc... mais de
la façon que j'ai tout monter peut importe les autres facteurs que ceux de
la largeur et de la longueur, sa ne change rien au bout du compte a part me
dire quel rouleau enlever de la base et placer en production etc ... donc
pou rles besoin de la cause ne tenont en consideration que jai 2 type de
rouleaux 6 pieds et 12 pieds et que chaque rouleau a une longueur!

Pour ce qui est d'utiliser le meme type de rouleau plus d'une fois , oui il
le faut si jen ai assez , par exemple si jai une commande qui nécessite 200
verges, donc je regarde si jai sufiseament de verge avec les 6 pieds ,
Pour ce qui est d'utiliser plusieur type de rouleau , je dirais oui et que
même c'est nécéssaire dans le cas ou je n'ai pas sufiseament de longueur
avec les rouleaux de 6 pieds mais que si je vais chercher 1 ou 2 rouleaux de
12 pieds par exemple sa completerais la commande !

Je resume sa par une simple verification tu va tout comprendre ,

myRQ.Open "select pattern_number,sum(Square_Yard) AS SumOfSquare_Yard
from roll_cutting group by pattern_number", mySQL, 1, 3

Do While Not (myRQ.EOF)
If myRQ.Fields("pattern_number").Value = monPatron Then
monCompteurSix = myRQ.Fields("sumofsquare_yard").Value
Exit Do
Else
myRQ.MoveNext
End If
Loop

donc comme tu peux voir dans mon recordset jai tout le total des verges
regroupé par patron , pour nous un patron équivaut à une couleur, ensuite je
loop tout les enregistrement pour trouver le total pour le patron en cours ,
et je refais tant et aussi longtemps que je n'ai pas fait le tour de tout la
commande !

D'après l'algo que tu développes ensuite j'ai l'impression que non.
Cependant il n'est pas évident que la meilleure méthode pour obtenir un
total consiste à prendre à chaque fois le nombre le plus proche :
Je dispose de 3,4,5 et 10 : pour faire 12 on voit qu'il faut utiliser

3+4+5.

Ton algo dirait qu'il faut utiliser 10+3.

bon point je n'avais pas réalisé ...

Si l'opération est réalisable avec des rouleaux de 6 (ou de 12), faut-il
regarder s'il y aurait moins de perte en mixant les deux catégories ?

non car je dois passer un maximum de rouleau de 6 pieds avant même de penser
au rouleau de 12 pieds

Pour ta troisième colonne, cela revient d'après ce que je comprends à
transformer en itératif une procédure éminemment récursive. On gagne en
espace mémoire et en temps mais on perd en compréhension et en facilité de
mise en ouvre.

oui et non , tout ce quon peut faire dans un
do while ordone <> TRUE
if 3iemme colonne = TRUE then
x = x + 1
else
traitement
etc...

Pour terminer, contrairement à ce qui était affirmé dans un mail

précédent,

la récursivité dépile correctement en fin de course.

Exemple

Function Factoriel(N as integer) as integer
If N=1 then
Factoriel=1
else
Factoriel=N*Factoriel(N-1)
End If
End Function


Donc quand on appelle Factoriel(3)
Empilage des paramètres de retour
N(1er appel) vaut 3
N diff de 1
Appel de Factoriel(2)
Empilage des paramètres de retour
N(2ème appel) vaut 2
N diff de 1
Appel de Factoriel(1)
Empilage des paramètres de retour
N(3ème appel) vaut 1
N=1
Valeur de retour(3ème appel) vaut 1
Dépilage des valeurs
Valeur de retour(2ème appel) vaut 2*Valeur de retour(3ème appel)
Valeur de retour(2ème appel) vaut 2
Dépilage des valeurs
Valeur de retour(1er appel) vaut 3*Valeur de retour(2ème appel)
Valeur de retour(1er appel) vaut 6
Factoriel(3) vaut 6

A bientôt.

"Himselff" <info@dmsinc.ca> a écrit dans le message de
news:CLVhc.68847$Gp4.1712083@news20.bellglobal.com...
> Merci Beaucoup Patrice pour le coup de main ,
>
> J'ai realiser qu'il yavait peut etre une autre solution pour determiner
> quel(s) rouleaux etait meilleur tu me dira ce que tu en pense,
>
> Si je calcule la valeur total pour tout les rouleaux de 6 pieds ensemble
sa
> me permet de voir si oui ou non jen ai sufiseament , meme chose pour les
12
> pieds, tu sera surement daccord pour dire que cest deux conditions sont
> essentiel, je dois egalement regarder dans la negative des 2 premieres

si

en
> combinant 6 et 12 pieds je ne ferais pas le compte, dans la negative
parfait
> on arrete tout et on passe a un autre numero,
>
> Dans laffirmative de lune ou lautre des conditions si je prend tout les

6

> pieds et les 12 pieds et je les met dans un tableau comme dans ton

exemple

,
> sauf quen ajoutant une colonne BOOLEAN qui me permeterais de dire TRUE

il

> est deja utiliser et FALSE tu peux continuer a le comparer,
>
> En comparant chaque rouleaux avec la valeur a atteindre sa me permet de
> trouver mon manque a gagner , ce qui me permet de trouver a chaque LOOP
quel
> rouleau est le meilleur et lui mettre TRUE dans son index et

Incrementer

ma
> valeur atteinte ce qui me donnerais une formule du genre :
> valeur a atteindre = valeur a atteindre - valeur du meilleur rouleau
> donc dans le loop suivante il passe par dessus le rouleau que je viens

de

> mettre a TRUE et regarde le manque a gagner des autre rouleaux et ainsi

de

> suite jusqua ce que ma valeur atteinte soit >= a valeur a atteindre du
> depart !
>
> Dis moi ce que tu en pense, je crois que cette methode est beaucoup plus
> simple que lautre , jai deja rempli les deux tableaux , calculer le

total

de
> tout les 6 pieds et de tout les 12 pieds , jai aussi determiner mon

manque

a
> gagner , ainsi que la quantite totale de 6 pieds et de 12 pieds pour les
> LOOP,
>
> Jattend de tes nouvelles , entre temps je vais continuer de progresser
vers
> cette methode et ten redonner des nouvelles , si tu veux que je post mon
> code dis la moi !
>
> Merci
>
> Fred
>
> "Patrice Henrio" <patrice.henrio.pasdepub@laposte.net> wrote in message
> news:#Eq6ltIKEHA.2880@TK2MSFTNGP10.phx.gbl...
> > Bon on va s'y mettre ce week-end. C'est quelque chose que j'ai déjà
fait.
> En
> > fait si j'ai bien compris, soit L une longueur, S un ensemble de
rouleaux
> de
> > six pieds, D un ensemble de rouleaux de douze pieds.
> > Il faut commencer par calculer s, la longueur totale des rouleaux de

six

> > pieds et d, la longueur totale des rouleaux de douze pieds : une

simple

> > boucle suffit : c'est surtout pour simplifier le problème si L<s ou
L>s+d.
> > C'est à dire si on peut tout faire en six pieds ou si le meilleur
résultat
> > n'est pas de tout utiliser.
> > Pendant la boucle on vérifie si il n'y aurait pas un rouleau de S ou

un

de
> D
> > qui convienne :
> >
> > Type t_Rouleaux
> > Longueur as integer
> > Nombre as Integer
> > End Type
> >
> > S et D sont des tableaux de rouleaux
> > Dim S(1 to NbSorteRouleaux6Pieds) as t_Rouleaux
> > Dim D(1 to NbSorteRouleaux6Pieds) as t_Rouleaux
> > Dim I as integer, R as integer
> >
> > Initialisation de S et D
> > LongueurTotaleS=0
> > R=0
> > For I=1 to NbSorteRouleaux6Pieds
> > If S(I).Longueur>L then
> > If I=1 then R=1
> > elseIf R=0 then R=I
> > elseIf S(I)<S(R) then R=I
> > End If
> > Else If R=0 then
> > LongueurTotaleS=LongueurTotaleS+S(I).Longueur*S(I).Nombre
> > End If
> > Next I
> >
> > Donc si à la sortie de la boucle R est <>0 alors tu peux réaliser ta
> > commander avce un rouleau de numéro R. Tu peux même améliorer la

gestion

> en
> > décomptant dans ce cas l'ensemble S d'une unité.
> > Si R=0, refaire la même chose avec D et LongueurTotaleD.
> > Et si LongueurTotaleS+LongueurTotaleD<L : on ne peut pas réaliser la
> > commande.
> > A bientôt pour la suite.
> >
> >
> > "Himselff" <info@dmsinc.ca> a écrit dans le message de
> > news:Z3Rhc.65496$Gp4.1642892@news20.bellglobal.com...
> > > Bon voici ou jen suis avec cette algo de fou ,
> > >
> > > Ce que je fais en premier lieu
> > > -je regarde si dans mes rouleaux de pieds il ny aurait pas un qui
fasse
> > le
> > > travail,
> > > -sinon je regarde la meme chose dans les 12 pieds,
> > > -je regarde egalement dans le cas dune super grosse commande si je

nai

> pas
> > > sufiseament de 6 pieds ni de 12 pieds, est ce que jen aurais
sufiseament
> > les
> > > 2 emsembles donc je prend tout les 6 pieds et je cherche quel est le
> > > meilleur 12 pieds pour atteindre le total requis pour la commande,
> > > -Si je nai qun 12 pieds qui est sufisant parfait tout fonctionne,
> > > -Par contre quand jai besoin de plus dun 12 pieds ...
> > >
> > > -Aussi je pourrais etre capable de completer ma commande avec
plusieurs
> 6
> > > pieds sauf que la encore meme probleme ,
> > >
> > > Donc si qque a deja deveolper autour de cet algo jaurais besoin de
petit
> > > indice pour me demarer !
> > >
> > > Merci beaucoup a lavance !
> > >
> > > Fred
> > > "Himselff" <info@dmsinc.ca> wrote in message
> > > news:fCOhc.64205$Gp4.1596466@news20.bellglobal.com...
> > > > Bonjour ,
> > > >
> > > > J'ai pris le temps de lire toute la documentation sur le probleme,
je
> > > > comprend tres bien le probleme et la solution, mais pour ce qui

est

de
> > > > mettre tout sa en pratique cest une autre histoire,
> > > >
> > > > ce que je crois, cest que premiere des choses je devrais mettre

tout

> les
> > > > rouleaux dans une variable tableau en ordre croissant qui nous
> > permeterais
> > > > detre capable de trier plus aisement par la suite, ensuite et bien
> > inserer
> > > > lalgorythme qui va trouver le - les meilleurs rouleau !
> > > >
> > > > Jattend vos suggestions car je ne sais trop de quelle facon

debuter

!
> > > >
> > > > Merci
> > > >
> > > > Fred
> > > > "le_troll" <le_trol@paris.fr> wrote in message
> > > > news:#Cl7aWFKEHA.2012@TK2MSFTNGP11.phx.gbl...
> > > > > La récursivité, je ne sais pas si c'est une bonne solution, car

je

> > crois
> > > > que
> > > > > ça ne dépile pas contrairement à une boucle, alors faut voir si

on

> ne
> > > > risque
> > > > > pas de sortir en "fin de pile", juste une petite réflexion
> > > > supplémentaire...
> > > > > Appeler une autre fonction, çan doit dépiler (end...), mais
appeler
> sa
> > > > > propre fonction, pas certain que ça dépile avant la fin du
> > traitement...
> > > > > --
> > > > > Merci, @+, bye, Joe
> > > > > montmartre75@iFrance.com
> > > > > ------------------------------------------
> > > > > Avec une hache, celui qui tient le manche a toujours raison !
> > > > > ------------------------------------------
> > > > >
> > > > >
> > > > > "Patrice Henrio" <patrice.henrio.pasdepub@laposte.net> a écrit
dans
> le
> > > > > message de news: OGFq409JEHA.1040@TK2MSFTNGP10.phx.gbl...
> > > > > > J'ai traité ce genre de problème sur ce forum il y a quelques
> temps
> > :
> > > il
> > > > > > fallait trouver la "meilleure" façon de réaliser une somme

avec

> > > > > différentes
> > > > > > pièces. Ici il s'agit de réaliser de la meilleure façon une
> > longueur
> > > > avec
> > > > > > différents rouleaux de certaines longueurs chacun.
> > > > > > On trouve l'explication de l'algorithme correspondant dans
> Structure
> > > te
> > > > > > interprétation des programmes informatiques de Abelson et
Sussman
> > > > (exemple
> > > > > > du chapitre 1.2.2). (la 1ère édition en français est épuisée.

La

> > 2ème
> > > > > > édition en anglais est disponible en ligne. [on peut

télécharger

> son
> > > > pdf],
> > > > > > http://deptinfo.unice.fr/~roy/sicp.pdf)
> > > > > > Il s'agit d'un algo récursif ce qui évite l'emploi de for next
> > > imbriqué
> > > > et
> > > > > > est plus compréhensible.
> > > > > > Avant de me lancer plus avant, que viennent faire les rouleaux
de
> 6
> > > > pieds
> > > > > > dans ce pb ?
> > > > > > En tout cas voici ce que ça donne avec les pièces de monnaies.
> > > > > > Example: Counting change
> > > > > > It takes only a bit of cleverness to come up with the

iterative

> > > > Fibonacci
> > > > > > algorithm. In contrast, consider the
> > > > > > following problem: How many different ways can we make change

of

$
> > > 1.00,
> > > > > > given half-dollars, quarters,
> > > > > > dimes, nickels, and pennies? More generally, can we write a
> > procedure
> > > to
> > > > > > compute the number of ways to
> > > > > > change any given amount of money?
> > > > > > This problem has a simple solution as a recursive procedure.
> Suppose
> > > we
> > > > > > think of the types of coins
> > > > > > available as arranged in some order. Then the following

relation

> > > holds:
> > > > > > The number of ways to change amount a using n kinds of coins
> equals
> > > > > > the number of ways to change amount a using all but the first
kind
> > of
> > > > > coin,
> > > > > > plus
> > > > > > the number of ways to change amount a - d using all n kinds of
> > coins,
> > > > > where
> > > > > > d is the denomination
> > > > > > of the first kind of coin.
> > > > > > To see why this is true, observe that the ways to make change
can
> be
> > > > > divided
> > > > > > into two groups: those that
> > > > > > do not use any of the first kind of coin, and those that do.
> > > Therefore,
> > > > > the
> > > > > > total number of ways to make
> > > > > > change for some amount is equal to the number of ways to make
> change
> > > for
> > > > > the
> > > > > > amount without using any
> > > > > > of the first kind of coin, plus the number of ways to make
change
> > > > assuming
> > > > > > that we do use the first kind of
> > > > > > coin. But the latter number is equal to the number of ways to
make
> > > > change
> > > > > > for the amount that remains
> > > > > > after using a coin of the first kind.
> > > > > > Thus, we can recursively reduce the problem of changing a

given

> > amount
> > > > to
> > > > > > the problem of changing
> > > > > > smaller amounts using fewer kinds of coins. Consider this
> reduction
> > > rule
> > > > > > carefully, and convince yourself
> > > > > > that we can use it to describe an algorithm if we specify the
> > > following
> > > > > > degenerate cases:
> > > > > > If a is exactly 0, we should count that as 1 way to make

change.

> > > > > > If a is less than 0, we should count that as 0 ways to make
> change.
> > > > > > If n is 0, we should count that as 0 ways to make change.
> > > > > > We can easily translate this description into a recursive
> procedure:
> > > > > >
> > > > > > (define (count-change amount)
> > > > > > (cc amount 5))
> > > > > >
> > > > > > (define (cc amount kinds-of-coins)
> > > > > > (cond ((= amount 0) 1)
> > > > > > ((or (< amount 0) (= kinds-of-coins 0)) 0)
> > > > > > (else (+ (cc amount
> > > > > > (- kinds-of-coins 1))
> > > > > > (cc (- amount
> > > > > > (first-denomination kinds-of-coins))
> > > > > > kinds-of-coins)))))
> > > > > >
> > > > > > (define (first-denomination kinds-of-coins)
> > > > > > (cond ((= kinds-of-coins 1) 1)
> > > > > > ((= kinds-of-coins 2) 5)
> > > > > > ((= kinds-of-coins 3) 10)
> > > > > > ((= kinds-of-coins 4) 25)
> > > > > > ((= kinds-of-coins 5) 50)))
> > > > > >
> > > > > > (The first-denomination procedure takes as input the number of
> kinds
> > > of
> > > > > > coins available and
> > > > > > returns the denomination of the first kind. Here we are

thinking

> of
> > > the
> > > > > > coins as arranged in order from
> > > > > > largest to smallest, but any order would do as well.) We can

now

> > > answer
> > > > > our
> > > > > > original question about
> > > > > > changing a dollar:
> > > > > > (count-change 100)
> > > > > > Count-change generates a tree-recursive process with
redundancies
> > > > similar
> > > > > to
> > > > > > those in our first
> > > > > > implementation of fib. (It will take quite a while for that

292

to
> > be
> > > > > > computed.) On the other hand, it is
> > > > > > not obvious how to design a better algorithm for computing the
> > result,
> > > > and
> > > > > > we leave this problem as a
> > > > > > challenge. The observation that a tree-recursive process may

be

> > highly
> > > > > > inefficient but often easy to specify
> > > > > > and understand has led people to propose that one could get

the

> best
> > > of
> > > > > both
> > > > > > worlds by designing a ``smart
> > > > > > compiler'' that could transform tree-recursive procedures into
> more
> > > > > > efficient procedures that compute the
> > > > > > same result.
> > > > > >
> > > > > > Si tu n'es pas familiarisé avec le Lisp et les langages
récursifs,
> > je
> > > > peux
> > > > > > t'aider dans ce projet.
> > > > > > En gros on part de l'idée que si f est une fonction permettant
> > > > d'atteindre
> > > > > L
> > > > > > avec des rouleaux d'un ensemble R, alors f atteint L-r1 avec

le

> même
> > > > > > ensemble R, dans lequel r1 est la longueur du premier rouleau
> > utilisé.
> > > > > >
> > > > > > J'ai l'impression que la première réponse avec problème NP
> évoquait
> > > > plutôt
> > > > > > celui du plus court chemin en passant par des points obligés.

Le

> > fait
> > > > > d'être
> > > > > > en dimension deux change beaucoup le pb.
> > > > > >
> > > > > >
> > > > > >
> > > > > > "Himselff" <info@dmsinc.ca> a écrit dans le message de
> > > > > > news:KNzhc.57140$Gp4.1302111@news20.bellglobal.com...
> > > > > > > Wow merci du tuyau , je commence les recherches tout de

suite

,
> > mais
> > > > je
> > > > > ne
> > > > > > > mattendais pas du tout a avoir a coder un ci gros algo ,
> > > > > > >
> > > > > > > youou moi qui aime les maths en plus =)
> > > > > > >
> > > > > > > souhaiter moi bonne chance =)
> > > > > > >
> > > > > > > Fred
> > > > > > >
> > > > > > > "Jean-Marc" <nospamjean_marc_n2@yahoo.fr> wrote in message
> > > > > > > news:4086c373$0$10948$a0ced6e1@news.skynet.be...
> > > > > > > > "Himselff" <info@dmsinc.ca> a écrit dans le message de
> > > > > > > > news:pGxhc.55193$Gp4.1267131@news20.bellglobal.com...
> > > > > > > > > bonjour tout le monde,
> > > > > > > > >
> > > > > > > > > Je suis convaincu que le probleme est bien simple

(encore

> une
> > > > > fois ),
> > > > > > > > voila
> > > > > > > > > je m'explique
> > > > > > > > >
> > > > > > > > > Jai 2 categories de produits les rouleaux de 6 pieds et
les
> > > > > rouleaux
> > > > > > de
> > > > > > > > 12
> > > > > > > > > pieds, pour realiser une commande ,
> > > > > > > > >
> > > > > > > > > Je dois selectionner selon le nombre de verge necessaire
les
> > > > > meilleurs
> > > > > > > > > rouleaux pour avoir le moin de perte possible, Jarrive
tres
> > bien
> > > a
> > > > > le
> > > > > > > > faire
> > > > > > > > > si par exemple jai assez de verge dans un rouleau , ou
meme
> si
> > > jai
> > > > > > > besoin
> > > > > > > > de
> > > > > > > > > tout les 6 pieds et un seul 12 pieds (par ordre de
priorite
> je
> > > > dois
> > > > > > > > prendre
> > > > > > > > > tout les 6 pieds avant de songer a prendre les 12 pieds)
> > > > > > > >
> > > > > > > > Hello,
> > > > > > > > ce problème n'est pas simple, il est même si compliqué que
> l'on
> > ne
> > > > > sait
> > > > > > > pas
> > > > > > > > produire une solution optimale en un temps fini. (c'est un
> > > problème
> > > > NP
> > > > > > > > complet en jargon mathématique).
> > > > > > > >
> > > > > > > > Ton problème est proche d'un problème générique connu sous
le
> > nom
> > > de
> > > > > > > > "programme du sac à dos". Il existe des méthodes de
résolution
> > qui
> > > > > > > arrivent
> > > > > > > > à une solution "la plus optimale possible" en un temps

fini.

> > > > > > > >
> > > > > > > > Tu trouveras une description de ce genre d'algorithme sur
> google
> > > en
> > > > > > > > cherchant "knapsack problem" ou encore "programmation
> linéaire"
> > ou
> > > > > > encore
> > > > > > > > "problème du sac à dos".
> > > > > > > >
> > > > > > > > Les explications et les justifications mathématiques sont

un

> peu
> > > > > (très)
> > > > > > > > ardues, mais on trouve assez aisément des implémentations

de

> > > > > > l'algorithme,
> > > > > > > > en pseudo code ou en C, aisées à traduire en VB.
> > > > > > > >
> > > > > > > > Jean-Marc
> > > > > > > >
> > > > > > > >
> > > > > > >
> > > > > > >
> > > > > >
> > > > > >
> > > > >
> > > > >
> > > >
> > > >
> > >
> > >
> >
> >
>
>