comment reduire ca

Le
giovanni
voila j ailes combinaison suivante
123 donc memoire 1 et memoire 2 et memoire 3 = total
124 donc memoire 1 et memoire 2 et memoire 4 = total2
125 etc
126
134
135
136
145
146
156
234
235
236
245
246
256
345
346
356
456

voici comme j'aifait moi pour la combinaison 123

if (nb_11==nb_1 || nb_11==nb_2 || nb_11==nb_3 || nb_11==nb_4 ||
nb_11==nb_5 || nb_11==nb_6)
{if (nb_22==nb_1 || nb_22==nb_2 || nb_22==nb_3 || nb_22==nb_4 ||
nb_22==nb_5 || nb_22==nb_6)
{if (nb_33==nb_1 || nb_33==nb_2 || nb_33==nb_3 || nb_33==nb_4 ||
nb_33==nb_5 || nb_33==nb_6)
{ ++t123; printf(" test t123=%d ",t123);}}}
et recopie la meme chose en changeant les memoire mais je n arrive pas avec
une boucle le faire et quel utiliser while do ou for ou case??
merci
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses Page 1 / 4
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Sylvain
Le #307074
giovanni wrote on 29/05/2007 00:56:
voila j ailes combinaison suivante
123,124,125,126,134,135


moi j'ai 258,456,741 et 963, tu fais des échanges ??

si tu cherches à faire qlq chose d'autres qu'une énumération
incompréhensible, n'hésites pas à indiquer en *l'expliquant*
- ce que tu cherches à faire
- puis ce que tu n'arrives pas à faire.

Sylvain.

James Kanze
Le #307072
On May 29, 1:33 am, Sylvain
giovanni wrote on 29/05/2007 00:56:

voila j ailes combinaison suivante
123,124,125,126,134,135


moi j'ai 258,456,741 et 963, tu fais des échanges ??

si tu cherches à faire qlq chose d'autres qu'une énumération
incompréhensible, n'hésites pas à indiquer en *l'expliquant*
- ce que tu cherches à faire
- puis ce que tu n'arrives pas à faire.


Je me démande : est-ce que la raison qu'il n'arrive pas à le
faire ne serait-elle pas qu'il ne sait l'expliquer ? J'ai
souvenr rémarquer qu'un bon programme commence par une bonne
spécification de ce qu'il faut faire. La reste est souvent plus
ou moins méchanique (non toujours, évidemment).

D'après la liste de chiffres qu'il a donné, je crois que ce
qu'il cherche, c'est toutes les combinaisons de 3 chiffres,
choisis parmi les 6 premiers. Il y a une solution simple (mais
très inefficace) pour le faire avec la bibliothèque standard,
utilise next_permutation pour générer toutes les permutations
des six chiffres, trie-les, et supprimer les dupliqués. À peu
près :

std::vector< int > ref ;
for ( int i = 1 ; i <= 6 ; ++ i ) {
ref.push_back( i ) ;
}
std::vector< std::vector< int > >
result ;
do {
std::vector< int > combi( ref.begin(), ref.begin() + 3 ) ;
std::sort( combi.begin(), combi.end() ) ;
result.push_back( combi ) ;
} while ( std::next_permutation( ref.begin(), ref.end() ) ) ;
std::sort( result.begin(), result.end() ) ;
result.erase( std::unique( result.begin(), result.end() ),
result.end() ) ;

Mais j'imagine que son prof veut qu'il trouve l'algorithme
lui-même (et ce n'est pas difficile d'en trouver une qui ne
génère pas les dupliqués, pour les supprimer par la suite).

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34


giovanni
Le #307029
ok merci jevais essayer
oui j'ai oublier de preciser sur une serie de 6 chiffre il me sort tout
toute les combinaison de trois .
et devrais par la suite prendre une autre combinaison de 6 chifre faire la
meme chose combinaison de trois posible et je ferai qu il regarde si une
combinaison et sortie eta addtionne +1 etc

"James Kanze"
On May 29, 1:33 am, Sylvain
giovanni wrote on 29/05/2007 00:56:

voila j ailes combinaison suivante
123,124,125,126,134,135


moi j'ai 258,456,741 et 963, tu fais des échanges ??

si tu cherches à faire qlq chose d'autres qu'une énumération
incompréhensible, n'hésites pas à indiquer en *l'expliquant*
- ce que tu cherches à faire
- puis ce que tu n'arrives pas à faire.


Je me démande : est-ce que la raison qu'il n'arrive pas à le
faire ne serait-elle pas qu'il ne sait l'expliquer ? J'ai
souvenr rémarquer qu'un bon programme commence par une bonne
spécification de ce qu'il faut faire. La reste est souvent plus
ou moins méchanique (non toujours, évidemment).

D'après la liste de chiffres qu'il a donné, je crois que ce
qu'il cherche, c'est toutes les combinaisons de 3 chiffres,
choisis parmi les 6 premiers. Il y a une solution simple (mais
très inefficace) pour le faire avec la bibliothèque standard,
utilise next_permutation pour générer toutes les permutations
des six chiffres, trie-les, et supprimer les dupliqués. À peu
près :

std::vector< int > ref ;
for ( int i = 1 ; i <= 6 ; ++ i ) {
ref.push_back( i ) ;
}
std::vector< std::vector< int > >
result ;
do {
std::vector< int > combi( ref.begin(), ref.begin() + 3 ) ;
std::sort( combi.begin(), combi.end() ) ;
result.push_back( combi ) ;
} while ( std::next_permutation( ref.begin(), ref.end() ) ) ;
std::sort( result.begin(), result.end() ) ;
result.erase( std::unique( result.begin(), result.end() ),
result.end() ) ;

Mais j'imagine que son prof veut qu'il trouve l'algorithme
lui-même (et ce n'est pas difficile d'en trouver une qui ne
génère pas les dupliqués, pour les supprimer par la suite).

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34


Mathias Gaunard
Le #307028

D'après la liste de chiffres qu'il a donné, je crois que ce
qu'il cherche, c'est toutes les combinaisons de 3 chiffres,
choisis parmi les 6 premiers. Il y a une solution simple (mais
très inefficace) pour le faire avec la bibliothèque standard,
utilise next_permutation pour générer toutes les permutations
des six chiffres, trie-les, et supprimer les dupliqués.


En utilisant un std::set ou unordered_set au lieu d'un std::vector on
supprime les deux dernières choses.

alex
Le #307027
c'est rigolo il me semble qu'il y a à peu près un an le même problème était
posé.
Un TD repris d'une année sur l'autre et toujours mal compris ;-) ?
Loïc Joly
Le #307023

D'après la liste de chiffres qu'il a donné, je crois que ce
qu'il cherche, c'est toutes les combinaisons de 3 chiffres,
choisis parmi les 6 premiers. Il y a une solution simple (mais
très inefficace) pour le faire avec la bibliothèque standard,
utilise next_permutation pour générer toutes les permutations
des six chiffres, trie-les, et supprimer les dupliqués.



En utilisant un std::set ou unordered_set au lieu d'un std::vector on
supprime les deux dernières choses.


Pour moi, on ne les supprime pas, on ne fait que les réaliser de manière
automatique par la STL. Ca restera quand même bien moins efficace
qu'un algo qui dès le début se débrouille pour ne pas générer certaines
permutations.

--
Loïc


James Kanze
Le #306980
On May 31, 9:09 pm, Loïc Joly wrote:


D'après la liste de chiffres qu'il a donné, je crois que ce
qu'il cherche, c'est toutes les combinaisons de 3 chiffres,
choisis parmi les 6 premiers. Il y a une solution simple (mais
très inefficace) pour le faire avec la bibliothèque standard,
utilise next_permutation pour générer toutes les permutations
des six chiffres, trie-les, et supprimer les dupliqués.


En utilisant un std::set ou unordered_set au lieu d'un std::vector on
supprime les deux dernières choses.


Pour moi, on ne les supprime pas, on ne fait que les réaliser
de manière automatique par la STL. Ca restera quand même bien
moins efficace qu'un algo qui dès le début se débrouille pour
ne pas générer certaines permutations.


Tout à fait, et c'est à ça que je pensais quand j'ai écrit
« (mais très inefficace) ». Pour 3 dans 6, je ne crois pas que
ça a de l'importance, mais pour 100 dans 1000... L'algorithme
que j'ai proposé est O(n!), quand même. (J'ai une assez bonne
idée de comment je m'attaquerais au problème, mais je ne connais
pas d'algorithme de tête pour le faire, et il n'y en a
certainement pas dans la bibliothèque standard.)

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34



Mathias Gaunard
Le #306979
c'est rigolo il me semble qu'il y a à peu près un an le même problème était
posé.
Un TD repris d'une année sur l'autre et toujours mal compris ;-) ?


Je croyais que c'était la même personne qui n'avait toujours pas trouvé
de réponse au problème.

David Fleury
Le #306977
On May 31, 9:09 pm, Loïc Joly wrote:


D'après la liste de chiffres qu'il a donné, je crois que ce
qu'il cherche, c'est toutes les combinaisons de 3 chiffres,
choisis parmi les 6 premiers. Il y a une solution simple (mais
très inefficace) pour le faire avec la bibliothèque standard,
utilise next_permutation pour générer toutes les permutations
des six chiffres, trie-les, et supprimer les dupliqués.


En utilisant un std::set ou unordered_set au lieu d'un std::vector on
supprime les deux dernières choses.


Pour moi, on ne les supprime pas, on ne fait que les réaliser
de manière automatique par la STL. Ca restera quand même bien
moins efficace qu'un algo qui dès le début se débrouille pour
ne pas générer certaines permutations.


Tout à fait, et c'est à ça que je pensais quand j'ai écrit
« (mais très inefficace) ». Pour 3 dans 6, je ne crois pas que
ça a de l'importance, mais pour 100 dans 1000... L'algorithme
que j'ai proposé est O(n!), quand même. (J'ai une assez bonne
idée de comment je m'attaquerais au problème, mais je ne connais
pas d'algorithme de tête pour le faire, et il n'y en a
certainement pas dans la bibliothèque standard.)



Juste pour savoir, la récursion ne serait pas une possibilité
acceptable ?

(j'ai pas encore trouvé l'itératif)

David.




giovanni
Le #306976
ok merci je vais essayer avec std.....si j arrive les vector pas mon fort
encore

"David Fleury" 46608fa7$0$27462$
On May 31, 9:09 pm, Loïc Joly wrote:


D'après la liste de chiffres qu'il a donné, je crois que ce
qu'il cherche, c'est toutes les combinaisons de 3 chiffres,
choisis parmi les 6 premiers. Il y a une solution simple (mais
très inefficace) pour le faire avec la bibliothèque standard,
utilise next_permutation pour générer toutes les permutations
des six chiffres, trie-les, et supprimer les dupliqués.


En utilisant un std::set ou unordered_set au lieu d'un std::vector on
supprime les deux dernières choses.


Pour moi, on ne les supprime pas, on ne fait que les réaliser
de manière automatique par la STL. Ca restera quand même bien
moins efficace qu'un algo qui dès le début se débrouille pour
ne pas générer certaines permutations.


Tout à fait, et c'est à ça que je pensais quand j'ai écrit
« (mais très inefficace) ». Pour 3 dans 6, je ne crois pas que
ça a de l'importance, mais pour 100 dans 1000... L'algorithme
que j'ai proposé est O(n!), quand même. (J'ai une assez bonne
idée de comment je m'attaquerais au problème, mais je ne connais
pas d'algorithme de tête pour le faire, et il n'y en a
certainement pas dans la bibliothèque standard.)



Juste pour savoir, la récursion ne serait pas une possibilité
acceptable ?

(j'ai pas encore trouvé l'itératif)

David.






Publicité
Poster une réponse
Anonyme