Petit Probleme de logique

Le
Himselff
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)

Mon probleme est dans la selection de multiple rouleau de 12 pieds,

par exemple :

- jai 5 rouleaux de 6 pieds qui donne 200 verges tous ensemble
- jai 4 rouleau de 12 pieds
1 = 100 verges
2 = 125 verges
3 = 106 verges
4 = 200 verges
- pour realiser ma commande jai besoin de 550 verges

donc en theorie je devrais prendre 1-3 et 4 qui sont les plus pres et qui
donne le moin de perte, quel serait l'algo que je devrait utiliser pour les
trouver ?

Merci beaucoup a lavance !

Fred
Vos réponses Page 1 / 2
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Himselff
Le #14670141
Petit ajout comme sa , jai mis 4 rouleaux mais sa peut etre beaucoup plus
cest vraiment que pour l'exemple !

=)

Fred

"Himselff" news:pGxhc.55193$
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)

Mon probleme est dans la selection de multiple rouleau de 12 pieds,

par exemple :

- jai 5 rouleaux de 6 pieds qui donne 200 verges tous ensemble
- jai 4 rouleau de 12 pieds
1 = 100 verges
2 = 125 verges
3 = 106 verges
4 = 200 verges
- pour realiser ma commande jai besoin de 550 verges

donc en theorie je devrais prendre 1-3 et 4 qui sont les plus pres et qui
donne le moin de perte, quel serait l'algo que je devrait utiliser pour


les
trouver ?

Merci beaucoup a lavance !

Fred




le_troll
Le #14670091
Bonjour,

L'exemple est pas facile à comprendre, surtout quand on ne connaît pas
les verges...
Le principe est de trouver les rouleaux qui seront les plus proche des
découpes dont tu as besoin avec le moins de chutes, alors je dirais une
comparaison en boucle, ou en liste, le problème et qu'il faut quasiment une
boucle par rouleau, ça peut être long, il faut faire toutes les combinaisons
possibles (à 4 tu dois monter dans les 14 combinaisons déjà, espérons que tu
n'as pas 100 rouleaux <>!!!
Prendre celle la plus proche de la découpe, genre:

3 rouleaux = r(3): les découpes offertes = d(7), taille recherchée= t, bon
rouleaux = b

1ere boucle, charge les possibilités avec les <> rouleaux
1 r1 = d1
2 r2Ò
3 r3Ó
4 r1+r2Ô
5 r1+r3Õ
6 r2+r3Ö
7 r1+r2+r3×
*
b00 'valeur de départ
for i = 1 to 7 ' 2eme boucle cherche la taille > mais la + proche
si d(x) < t exit for ' trop petit
si d(x) > t then et d(x) < b
b=d(x) ' prend à chaque fois le lus proche de 0 (taille requise)
endif
next i

le résultat devrait te donner i=x -> variable(i) = énumérant le n° des
rouleaux à prendre

Je pense que j'y arriverais comme ça, mais ce n'est pas beau, faudrait un
matheux pour te faire un beau truc, le plus grand problème c'est les boucles
imbriquées pour avoir la longueur selon toutes les combinaisons possible, un
peu comme faire toutes les combinaisons à 7 chiffres du loto avec les 49
numéros...
--
Merci, @+, bye, Joe

------------------------------------------
Avec une hache, celui qui tient le manche a toujours raison !
------------------------------------------


"Himselff" pGxhc.55193$
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)

Mon probleme est dans la selection de multiple rouleau de 12 pieds,

par exemple :

- jai 5 rouleaux de 6 pieds qui donne 200 verges tous ensemble
- jai 4 rouleau de 12 pieds
1 = 100 verges
2 = 125 verges
3 = 106 verges
4 = 200 verges
- pour realiser ma commande jai besoin de 550 verges

donc en theorie je devrais prendre 1-3 et 4 qui sont les plus pres et qui
donne le moin de perte, quel serait l'algo que je devrait utiliser pour


les
trouver ?

Merci beaucoup a lavance !

Fred




Himselff
Le #14670081
tout a fait daccord avec toi sa va prendre quelque principe pour automatiser
tout sa parceque tout determiner chaque possibilite sa peut devenir tres
lourd
,
et oui cest tres possible que jaie plus de 100 rouleaux,
pour ce qui est de verges cest une unitees de mesure Americain je crois bien
mais si cest plus simple on peut simplement dire des metres pour lexemple de
toute facon cest seulement le traitement des valeurs qui est important !

"le_troll" news:OV#
Bonjour,

L'exemple est pas facile à comprendre, surtout quand on ne connaît pas
les verges...
Le principe est de trouver les rouleaux qui seront les plus proche des
découpes dont tu as besoin avec le moins de chutes, alors je dirais une
comparaison en boucle, ou en liste, le problème et qu'il faut quasiment


une
boucle par rouleau, ça peut être long, il faut faire toutes les


combinaisons
possibles (à 4 tu dois monter dans les 14 combinaisons déjà, espérons que


tu
n'as pas 100 rouleaux <>!!!
Prendre celle la plus proche de la découpe, genre:

3 rouleaux = r(3): les découpes offertes = d(7), taille recherchée= t, bon
rouleaux = b

1ere boucle, charge les possibilités avec les <> rouleaux
1 r1 = d1
2 r2Ò
3 r3Ó
4 r1+r2Ô
5 r1+r3Õ
6 r2+r3Ö
7 r1+r2+r3×
*
b00 'valeur de départ
for i = 1 to 7 ' 2eme boucle cherche la taille > mais la + proche
si d(x) < t exit for ' trop petit
si d(x) > t then et d(x) < b
b=d(x) ' prend à chaque fois le lus proche de 0 (taille requise)
endif
next i

le résultat devrait te donner i=x -> variable(i) = énumérant le n° des
rouleaux à prendre

Je pense que j'y arriverais comme ça, mais ce n'est pas beau, faudrait un
matheux pour te faire un beau truc, le plus grand problème c'est les


boucles
imbriquées pour avoir la longueur selon toutes les combinaisons possible,


un
peu comme faire toutes les combinaisons à 7 chiffres du loto avec les 49
numéros...
--
Merci, @+, bye, Joe

------------------------------------------
Avec une hache, celui qui tient le manche a toujours raison !
------------------------------------------


"Himselff" pGxhc.55193$
> 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)
>
> Mon probleme est dans la selection de multiple rouleau de 12 pieds,
>
> par exemple :
>
> - jai 5 rouleaux de 6 pieds qui donne 200 verges tous ensemble
> - jai 4 rouleau de 12 pieds
> 1 = 100 verges
> 2 = 125 verges
> 3 = 106 verges
> 4 = 200 verges
> - pour realiser ma commande jai besoin de 550 verges
>
> donc en theorie je devrais prendre 1-3 et 4 qui sont les plus pres et


qui
> donne le moin de perte, quel serait l'algo que je devrait utiliser pour
les
> trouver ?
>
> Merci beaucoup a lavance !
>
> Fred
>
>







Jean-Marc
Le #14670041
"Himselff" news:pGxhc.55193$
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
Himselff
Le #14670031
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" news:4086c373$0$10948$
"Himselff" news:pGxhc.55193$
> 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




Patrice Henrio
Le #14670011
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" news:KNzhc.57140$
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" news:4086c373$0$10948$
> "Himselff" > news:pGxhc.55193$
> > 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
>
>




Himselff
Le #14670001
> Avant de me lancer plus avant, que viennent faire les rouleaux de 6 pieds
dans ce pb ?



Dans le fond sa ne change pas grand chose a part baisser la valeur a
atteindre dans lalgo , suivant le principe de lalgo jai une valeur X a
ateindre en utilisant les meilleurs resultats possible dans ce cas la valeur
a atteindre est egale a la valeur a ateidre - la longueur de tout les
rouleaux de 6 pieds ensemble, il me reste par la suite qua trouver quel(s)
12 pieds fera le travail pour atteindre le reste de la valeur !

Jespere que cest plus claires !

Merci pour le lien je vais tout etudier sa ce soir a tete reposer et je vous
reviens la dessus demain !

Fred

"Patrice Henrio" news:
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" news:KNzhc.57140$
> 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" > news:4086c373$0$10948$
> > "Himselff" > > news:pGxhc.55193$
> > > 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
> >
> >
>
>




le_troll
Le #14712041
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

------------------------------------------
Avec une hache, celui qui tient le manche a toujours raison !
------------------------------------------


"Patrice Henrio" message de news:
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" news:KNzhc.57140$
> 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" > news:4086c373$0$10948$
> > "Himselff" > > news:pGxhc.55193$
> > > 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
> >
> >
>
>




Himselff
Le #14711961
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" news:#
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

------------------------------------------
Avec une hache, celui qui tient le manche a toujours raison !
------------------------------------------


"Patrice Henrio" message de news:
> 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" > news:KNzhc.57140$
> > 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" > > news:4086c373$0$10948$
> > > "Himselff" > > > news:pGxhc.55193$
> > > > 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
> > >
> > >
> >
> >
>
>




Himselff
Le #14711841
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" news:fCOhc.64205$
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" news:#
> 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
>
> ------------------------------------------
> Avec une hache, celui qui tient le manche a toujours raison !
> ------------------------------------------
>
>
> "Patrice Henrio" > message de news:
> > 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" > > news:KNzhc.57140$
> > > 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" > > > news:4086c373$0$10948$
> > > > "Himselff" > > > > news:pGxhc.55193$
> > > > > 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
> > > >
> > > >
> > >
> > >
> >
> >
>
>




Publicité
Poster une réponse
Anonyme