euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
"Michael DOUBEZ" a écrit dans le message de news:
Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne (avec un
nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un multiset) et
tu calcules leur intersection avec l'algorithme set_intersection().
Ensuite, il suffit d'obtenir la taille de l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter le
nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de news:
Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne (avec un
nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un multiset) et
tu calcules leur intersection avec l'algorithme set_intersection().
Ensuite, il suffit d'obtenir la taille de l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter le
nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
"Michael DOUBEZ" a écrit dans le message de news:
Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne (avec un
nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un multiset) et
tu calcules leur intersection avec l'algorithme set_intersection().
Ensuite, il suffit d'obtenir la taille de l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter le
nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
wrote:euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);
"Michael DOUBEZ" a écrit dans le message de
news:
[snip]Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne (avec
un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un multiset)
et tu calcules leur intersection avec l'algorithme set_intersection().
Ensuite, il suffit d'obtenir la taille de l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter le
nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
--
Michael
giovannisch@hotmail.com wrote:
euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de
news:
[snip]
Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne (avec
un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un multiset)
et tu calcules leur intersection avec l'algorithme set_intersection().
Ensuite, il suffit d'obtenir la taille de l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter le
nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
--
Michael
wrote:euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);
"Michael DOUBEZ" a écrit dans le message de
news:
[snip]Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne (avec
un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un multiset)
et tu calcules leur intersection avec l'algorithme set_intersection().
Ensuite, il suffit d'obtenir la taille de l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter le
nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
--
Michael
la je comprend pas je suis encore debutant et la les vector ou ce que tu as
ecris je sais pas le mettre en pratique en prog...
"Michael DOUBEZ" a écrit dans le message de news:
49cba766$0$24827$wrote:euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);"Michael DOUBEZ" a écrit dans le message de
news:
[snip]Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne (avec
un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un multiset)
et tu calcules leur intersection avec l'algorithme set_intersection().
Ensuite, il suffit d'obtenir la taille de l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter le
nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
la je comprend pas je suis encore debutant et la les vector ou ce que tu as
ecris je sais pas le mettre en pratique en prog...
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de news:
49cba766$0$24827$426a74cc@news.free.fr...
giovannisch@hotmail.com wrote:
euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de
news:
[snip]
Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne (avec
un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un multiset)
et tu calcules leur intersection avec l'algorithme set_intersection().
Ensuite, il suffit d'obtenir la taille de l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter le
nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
la je comprend pas je suis encore debutant et la les vector ou ce que tu as
ecris je sais pas le mettre en pratique en prog...
"Michael DOUBEZ" a écrit dans le message de news:
49cba766$0$24827$wrote:euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);"Michael DOUBEZ" a écrit dans le message de
news:
[snip]Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne (avec
un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un multiset)
et tu calcules leur intersection avec l'algorithme set_intersection().
Ensuite, il suffit d'obtenir la taille de l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter le
nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
wrote:la je comprend pas je suis encore debutant et la les vector ou ce que tu
as ecris je sais pas le mettre en pratique en prog...
Si tu sais lire des données d'un fichier, les mettre dans un tableau, les
trier, la suite est suivant l'algorithme suivant:
const int data_nb = 5;
typedef int data_type[data_nb];
// renvoie le nombre de nombres égaux dans deux lignes
// pre: les paramètres sont triés par ordre croissant
int count_intersect(const data_type& bag1, const data_type& bag2)
{
int count=0; // compte le nombre d'éléments égaux
int i1=0; // index dans bag1
int i2=0; //index dans bag2
while( (i1<data_nb) && (i2<data_nb) )
{
if ( bag1[i1] < bag2[i2] )
{ // regarde l'élément suivant de bag1 pour égalité
++i1;
}
else if ( bag2[i2] < bag1[i1] )
{ // regarde l'élément suivant de bag2 pour égalité
++i2;
}
else // bag1[i1] =ºg2[i2]*/
{ // les éléments sont égaux - ajouter au compteur
++i1;++i2;
++count;
}
}
return count;
}
Dans ta boucle de lecture:
data_type bag1={12,34,56,67,89};
data_type bag2={19,34,45,56,56};
int t=count_intersect(bag1,bag2);
assert( t == 2 );"Michael DOUBEZ" a écrit dans le message de
news: 49cba766$0$24827$wrote:euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);"Michael DOUBEZ" a écrit dans le message de
news:
[snip]Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne
(avec un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un
multiset) et tu calcules leur intersection avec l'algorithme
set_intersection(). Ensuite, il suffit d'obtenir la taille de
l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter
le nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
--
Michael
giovannisch@hotmail.com wrote:
la je comprend pas je suis encore debutant et la les vector ou ce que tu
as ecris je sais pas le mettre en pratique en prog...
Si tu sais lire des données d'un fichier, les mettre dans un tableau, les
trier, la suite est suivant l'algorithme suivant:
const int data_nb = 5;
typedef int data_type[data_nb];
// renvoie le nombre de nombres égaux dans deux lignes
// pre: les paramètres sont triés par ordre croissant
int count_intersect(const data_type& bag1, const data_type& bag2)
{
int count=0; // compte le nombre d'éléments égaux
int i1=0; // index dans bag1
int i2=0; //index dans bag2
while( (i1<data_nb) && (i2<data_nb) )
{
if ( bag1[i1] < bag2[i2] )
{ // regarde l'élément suivant de bag1 pour égalité
++i1;
}
else if ( bag2[i2] < bag1[i1] )
{ // regarde l'élément suivant de bag2 pour égalité
++i2;
}
else // bag1[i1] =ºg2[i2]*/
{ // les éléments sont égaux - ajouter au compteur
++i1;++i2;
++count;
}
}
return count;
}
Dans ta boucle de lecture:
data_type bag1={12,34,56,67,89};
data_type bag2={19,34,45,56,56};
int t=count_intersect(bag1,bag2);
assert( t == 2 );
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de
news: 49cba766$0$24827$426a74cc@news.free.fr...
giovannisch@hotmail.com wrote:
euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de
news:
[snip]
Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne
(avec un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un
multiset) et tu calcules leur intersection avec l'algorithme
set_intersection(). Ensuite, il suffit d'obtenir la taille de
l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter
le nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
--
Michael
wrote:la je comprend pas je suis encore debutant et la les vector ou ce que tu
as ecris je sais pas le mettre en pratique en prog...
Si tu sais lire des données d'un fichier, les mettre dans un tableau, les
trier, la suite est suivant l'algorithme suivant:
const int data_nb = 5;
typedef int data_type[data_nb];
// renvoie le nombre de nombres égaux dans deux lignes
// pre: les paramètres sont triés par ordre croissant
int count_intersect(const data_type& bag1, const data_type& bag2)
{
int count=0; // compte le nombre d'éléments égaux
int i1=0; // index dans bag1
int i2=0; //index dans bag2
while( (i1<data_nb) && (i2<data_nb) )
{
if ( bag1[i1] < bag2[i2] )
{ // regarde l'élément suivant de bag1 pour égalité
++i1;
}
else if ( bag2[i2] < bag1[i1] )
{ // regarde l'élément suivant de bag2 pour égalité
++i2;
}
else // bag1[i1] =ºg2[i2]*/
{ // les éléments sont égaux - ajouter au compteur
++i1;++i2;
++count;
}
}
return count;
}
Dans ta boucle de lecture:
data_type bag1={12,34,56,67,89};
data_type bag2={19,34,45,56,56};
int t=count_intersect(bag1,bag2);
assert( t == 2 );"Michael DOUBEZ" a écrit dans le message de
news: 49cba766$0$24827$wrote:euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);"Michael DOUBEZ" a écrit dans le message de
news:
[snip]Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne
(avec un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un
multiset) et tu calcules leur intersection avec l'algorithme
set_intersection(). Ensuite, il suffit d'obtenir la taille de
l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter
le nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
--
Michael
donc les mettre dans tableau avec vector tu veu dire et bien moi je les
laisser dans les variable ...comem je sais pas encore mettre dans untableau
de taille inconnu et acceder a chaque ligne pour controler
et ca
data_type bag1={12,34,56,67,89}; les chiffre 12.34 etc je dois les
marquer pour chaque ligne ou du deuxieme fichier
ou le ferra tout seul
"Michael DOUBEZ" a écrit dans le message de news:
49cc9309$0$12936$wrote:la je comprend pas je suis encore debutant et la les vector ou ce que tu
as ecris je sais pas le mettre en pratique en prog...
Si tu sais lire des données d'un fichier, les mettre dans un tableau, les
trier, la suite est suivant l'algorithme suivant:
const int data_nb = 5;
typedef int data_type[data_nb];
// renvoie le nombre de nombres égaux dans deux lignes
// pre: les paramètres sont triés par ordre croissant
int count_intersect(const data_type& bag1, const data_type& bag2)
{
int count=0; // compte le nombre d'éléments égaux
int i1=0; // index dans bag1
int i2=0; //index dans bag2
while( (i1<data_nb) && (i2<data_nb) )
{
if ( bag1[i1] < bag2[i2] )
{ // regarde l'élément suivant de bag1 pour égalité
++i1;
}
else if ( bag2[i2] < bag1[i1] )
{ // regarde l'élément suivant de bag2 pour égalité
++i2;
}
else // bag1[i1] =ºg2[i2]*/
{ // les éléments sont égaux - ajouter au compteur
++i1;++i2;
++count;
}
}
return count;
}
Dans ta boucle de lecture:
data_type bag1={12,34,56,67,89};
data_type bag2={19,34,45,56,56};
int t=count_intersect(bag1,bag2);
assert( t == 2 );"Michael DOUBEZ" a écrit dans le message de
news: 49cba766$0$24827$wrote:euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);"Michael DOUBEZ" a écrit dans le message de
news:
[snip]Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne
(avec un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un
multiset) et tu calcules leur intersection avec l'algorithme
set_intersection(). Ensuite, il suffit d'obtenir la taille de
l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter
le nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
--
Michael
donc les mettre dans tableau avec vector tu veu dire et bien moi je les
laisser dans les variable ...comem je sais pas encore mettre dans untableau
de taille inconnu et acceder a chaque ligne pour controler
et ca
data_type bag1={12,34,56,67,89}; les chiffre 12.34 etc je dois les
marquer pour chaque ligne ou du deuxieme fichier
ou le ferra tout seul
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de news:
49cc9309$0$12936$426a74cc@news.free.fr...
giovannisch@hotmail.com wrote:
la je comprend pas je suis encore debutant et la les vector ou ce que tu
as ecris je sais pas le mettre en pratique en prog...
Si tu sais lire des données d'un fichier, les mettre dans un tableau, les
trier, la suite est suivant l'algorithme suivant:
const int data_nb = 5;
typedef int data_type[data_nb];
// renvoie le nombre de nombres égaux dans deux lignes
// pre: les paramètres sont triés par ordre croissant
int count_intersect(const data_type& bag1, const data_type& bag2)
{
int count=0; // compte le nombre d'éléments égaux
int i1=0; // index dans bag1
int i2=0; //index dans bag2
while( (i1<data_nb) && (i2<data_nb) )
{
if ( bag1[i1] < bag2[i2] )
{ // regarde l'élément suivant de bag1 pour égalité
++i1;
}
else if ( bag2[i2] < bag1[i1] )
{ // regarde l'élément suivant de bag2 pour égalité
++i2;
}
else // bag1[i1] =ºg2[i2]*/
{ // les éléments sont égaux - ajouter au compteur
++i1;++i2;
++count;
}
}
return count;
}
Dans ta boucle de lecture:
data_type bag1={12,34,56,67,89};
data_type bag2={19,34,45,56,56};
int t=count_intersect(bag1,bag2);
assert( t == 2 );
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de
news: 49cba766$0$24827$426a74cc@news.free.fr...
giovannisch@hotmail.com wrote:
euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de
news:
[snip]
Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne
(avec un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un
multiset) et tu calcules leur intersection avec l'algorithme
set_intersection(). Ensuite, il suffit d'obtenir la taille de
l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter
le nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
--
Michael
donc les mettre dans tableau avec vector tu veu dire et bien moi je les
laisser dans les variable ...comem je sais pas encore mettre dans untableau
de taille inconnu et acceder a chaque ligne pour controler
et ca
data_type bag1={12,34,56,67,89}; les chiffre 12.34 etc je dois les
marquer pour chaque ligne ou du deuxieme fichier
ou le ferra tout seul
"Michael DOUBEZ" a écrit dans le message de news:
49cc9309$0$12936$wrote:la je comprend pas je suis encore debutant et la les vector ou ce que tu
as ecris je sais pas le mettre en pratique en prog...
Si tu sais lire des données d'un fichier, les mettre dans un tableau, les
trier, la suite est suivant l'algorithme suivant:
const int data_nb = 5;
typedef int data_type[data_nb];
// renvoie le nombre de nombres égaux dans deux lignes
// pre: les paramètres sont triés par ordre croissant
int count_intersect(const data_type& bag1, const data_type& bag2)
{
int count=0; // compte le nombre d'éléments égaux
int i1=0; // index dans bag1
int i2=0; //index dans bag2
while( (i1<data_nb) && (i2<data_nb) )
{
if ( bag1[i1] < bag2[i2] )
{ // regarde l'élément suivant de bag1 pour égalité
++i1;
}
else if ( bag2[i2] < bag1[i1] )
{ // regarde l'élément suivant de bag2 pour égalité
++i2;
}
else // bag1[i1] =ºg2[i2]*/
{ // les éléments sont égaux - ajouter au compteur
++i1;++i2;
++count;
}
}
return count;
}
Dans ta boucle de lecture:
data_type bag1={12,34,56,67,89};
data_type bag2={19,34,45,56,56};
int t=count_intersect(bag1,bag2);
assert( t == 2 );"Michael DOUBEZ" a écrit dans le message de
news: 49cba766$0$24827$wrote:euh la j'arrive a comprenre le prog comme je connais pas
mais pas tout a fais ca encore je crois
en va faire un exemple plus concret :
fichier 1:
1234 12 34 56 67 89
4321 23 32 43 54 65
9876 1 2 3 4 5
fichier 2:
1234 89 56 45 45 56
7412 59 67 12 34 01
8523 54 65 02 03 07
donc comapre la ligne 1 du fichier avec toute les ligne du fichier 2
1234 12 34 56 67 89 <> 1234 89 56 45 45 56
il y a 2 equivalent le 56 89 donc ajouterai a +1 a t2 par exemple
ensuite compare
toujours ligne 1 avec ligne deux fu fichier 2
1234 12 34 56 67 89 <>7412 59 67 12 34 01
la aussi 2 equivalence donc ajoute +1 a t2
etc
quand fini avec de lire toute le fichier 2
me dit ligne 1 t2=2 dans notre exemple t3= 56 etc etc
et aprs l fais la meme chose avec la ligne 2 du fichier
4321 23 32 43 54 65 <> 1234 89 56 45 45 56
la y a rien
4321 23 32 43 54 65 <> 7412 59 67 12 34 01
la non plus
4321 23 32 43 54 65 <> 8523 54 65 32 03 07
la y a 3 donc t3+1
et ainsi de suite je pense plus claire la non
Ca correspond avec ce que j'ai dit.
De ton fichier1 et fichier2, sur une iteration, tu as les tableaux:
std::tr1::array<int,5> bag1={12,34,56,67,89};
std::tr1::array<int,5> bag2={19,56,45,45,56};
Tes données ont l'air d'être déjà triée mais si ce n'est pas le cas:
std::sort(bag1.begin(),bag1.end());
std::sort(bag2.begin(),bag2.end());
Calculer l'intersection des multisets:
int bag_intersect[5];
int* end=std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
&bag_intersect[0]
);
Calculer le nombre d'élément de l'intersection
int count=(end-bag_intersect)/sizeof(bag_intersect[0]);
Ou bien avec l'iterator donné en bas:
int count=0;
std::set_intersection(
bag1.begin(),bag1.end(),
bag2.begin(),bag2.end(),
count_iterator(count)
);"Michael DOUBEZ" a écrit dans le message de
news:
[snip]Un peu plus. Je reformule:
D'un fichier, tu lis des groupes de 5 nombres organisés par ligne
(avec un nombre en début de ligne que tu ignore).
Ensuite, pour chaque groupe de ces 5 nombre, tu fais ce qui suit:
Ouvrir un deuxième fichier de même format Et compter
le nombre de lignes qui comportent le même nombre de nombres égaux
avec un minimum de deux nombres égaux.
Mathématiquement, tu calcules les cardinalités des intersections des
multiensembles.
Pour cela, tu tries tes entrées de 5 nombre (ou tu utilise un
multiset) et tu calcules leur intersection avec l'algorithme
set_intersection(). Ensuite, il suffit d'obtenir la taille de
l'intersection.
Alternativement, tu peux utiliser un iterator qui ne fait que compter
le nombre de fois où il est incrémenté dans set_intersection().
struct count_iterator:
public std::iterator<std::output_iterator_tag, void>
{
int* counter;
count_iterator(int& c):counter(&c){}
count_iterator& operator++(){++*counter;return(*this);}
count_iterator& operator++(int){++*counter;return(*this);}
count_iterator& operator*(){return *this;}
count_iterator* operator->(){return this;}
count_iterator& operator=(const count_iterator& i){counter=i.t;}
template<class T>
count_iterator& operator=(const T&){return *this;}
};
--
Michael
donc les mettre dans tableau avec vector tu veu dire et bien moi je les
laisser dans les variable ...comem je sais pas encore mettre dans untableau
de taille inconnu et acceder a chaque ligne pour controler
et ca
data_type bag1={12,34,56,67,89}; les chiffre 12.34 etc je dois les
marquer pour chaque ligne ou du deuxieme fichier
ou le ferra tout seul
"Michael DOUBEZ" a écrit dans le message de news:
49cc9309$0$12936$wrote:la je comprend pas je suis encore debutant et la les vector ou ce que tu
as ecris je sais pas le mettre en pratique en prog...
Si tu sais lire des données d'un fichier, les mettre dans un tableau, les
trier, la suite est suivant l'algorithme suivant:
const int data_nb = 5;
typedef int data_type[data_nb];
// renvoie le nombre de nombres égaux dans deux lignes
// pre: les paramètres sont triés par ordre croissant
int count_intersect(const data_type& bag1, const data_type& bag2)
{
int count=0; // compte le nombre d'éléments égaux
int i1=0; // index dans bag1
int i2=0; //index dans bag2
while( (i1<data_nb) && (i2<data_nb) )
{
if ( bag1[i1] < bag2[i2] )
{ // regarde l'élément suivant de bag1 pour égalité
++i1;
}
else if ( bag2[i2] < bag1[i1] )
{ // regarde l'élément suivant de bag2 pour égalité
++i2;
}
else // bag1[i1] =ºg2[i2]*/
{ // les éléments sont égaux - ajouter au compteur
++i1;++i2;
++count;
}
}
return count;
}
Dans ta boucle de lecture:
data_type bag1={12,34,56,67,89};
data_type bag2={19,34,45,56,56};
int t=count_intersect(bag1,bag2);
assert( t == 2 );
donc les mettre dans tableau avec vector tu veu dire et bien moi je les
laisser dans les variable ...comem je sais pas encore mettre dans untableau
de taille inconnu et acceder a chaque ligne pour controler
et ca
data_type bag1={12,34,56,67,89}; les chiffre 12.34 etc je dois les
marquer pour chaque ligne ou du deuxieme fichier
ou le ferra tout seul
"Michael DOUBEZ" <michael.doubez@free.fr> a écrit dans le message de news:
49cc9309$0$12936$426a74cc@news.free.fr...
giovannisch@hotmail.com wrote:
la je comprend pas je suis encore debutant et la les vector ou ce que tu
as ecris je sais pas le mettre en pratique en prog...
Si tu sais lire des données d'un fichier, les mettre dans un tableau, les
trier, la suite est suivant l'algorithme suivant:
const int data_nb = 5;
typedef int data_type[data_nb];
// renvoie le nombre de nombres égaux dans deux lignes
// pre: les paramètres sont triés par ordre croissant
int count_intersect(const data_type& bag1, const data_type& bag2)
{
int count=0; // compte le nombre d'éléments égaux
int i1=0; // index dans bag1
int i2=0; //index dans bag2
while( (i1<data_nb) && (i2<data_nb) )
{
if ( bag1[i1] < bag2[i2] )
{ // regarde l'élément suivant de bag1 pour égalité
++i1;
}
else if ( bag2[i2] < bag1[i1] )
{ // regarde l'élément suivant de bag2 pour égalité
++i2;
}
else // bag1[i1] =ºg2[i2]*/
{ // les éléments sont égaux - ajouter au compteur
++i1;++i2;
++count;
}
}
return count;
}
Dans ta boucle de lecture:
data_type bag1={12,34,56,67,89};
data_type bag2={19,34,45,56,56};
int t=count_intersect(bag1,bag2);
assert( t == 2 );
donc les mettre dans tableau avec vector tu veu dire et bien moi je les
laisser dans les variable ...comem je sais pas encore mettre dans untableau
de taille inconnu et acceder a chaque ligne pour controler
et ca
data_type bag1={12,34,56,67,89}; les chiffre 12.34 etc je dois les
marquer pour chaque ligne ou du deuxieme fichier
ou le ferra tout seul
"Michael DOUBEZ" a écrit dans le message de news:
49cc9309$0$12936$wrote:la je comprend pas je suis encore debutant et la les vector ou ce que tu
as ecris je sais pas le mettre en pratique en prog...
Si tu sais lire des données d'un fichier, les mettre dans un tableau, les
trier, la suite est suivant l'algorithme suivant:
const int data_nb = 5;
typedef int data_type[data_nb];
// renvoie le nombre de nombres égaux dans deux lignes
// pre: les paramètres sont triés par ordre croissant
int count_intersect(const data_type& bag1, const data_type& bag2)
{
int count=0; // compte le nombre d'éléments égaux
int i1=0; // index dans bag1
int i2=0; //index dans bag2
while( (i1<data_nb) && (i2<data_nb) )
{
if ( bag1[i1] < bag2[i2] )
{ // regarde l'élément suivant de bag1 pour égalité
++i1;
}
else if ( bag2[i2] < bag1[i1] )
{ // regarde l'élément suivant de bag2 pour égalité
++i2;
}
else // bag1[i1] =ºg2[i2]*/
{ // les éléments sont égaux - ajouter au compteur
++i1;++i2;
++count;
}
}
return count;
}
Dans ta boucle de lecture:
data_type bag1={12,34,56,67,89};
data_type bag2={19,34,45,56,56};
int t=count_intersect(bag1,bag2);
assert( t == 2 );