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 \n",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
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.
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.
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.
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
On May 29, 1:33 am, Sylvain <noS...@mail.net> wrote:
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:james.kanze@gmail.com
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
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
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
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
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" <james.kanze@gmail.com> a écrit dans le message de news:
1180423054.361402.174700@q75g2000hsh.googlegroups.com...
On May 29, 1:33 am, Sylvain <noS...@mail.net> wrote:
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:james.kanze@gmail.com
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
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
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
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.
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.
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
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 ;-) ?
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 ;-) ?
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
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
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.
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
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
On May 31, 9:09 pm, Loïc Joly <loic.actarus.j...@numericable.fr>
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:james.kanze@gmail.com
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
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
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.
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.
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
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.
On May 31, 9:09 pm, Loïc Joly <loic.actarus.j...@numericable.fr>
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 ?
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
ok merci je vais essayer avec std.....si j arrive les vector pas mon fort encore
"David Fleury" a écrit dans le message de news: 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.
ok merci je vais essayer avec std.....si j arrive les vector pas mon fort
encore
"David Fleury" <dfleury2@libertysurf.fr> a écrit dans le message de news:
46608fa7$0$27462$426a74cc@news.free.fr...
On May 31, 9:09 pm, Loïc Joly <loic.actarus.j...@numericable.fr>
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 ?
ok merci je vais essayer avec std.....si j arrive les vector pas mon fort encore
"David Fleury" a écrit dans le message de news: 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 ?
