Bonjour à tous,
je dispose de 2 std::vector, et je voudrais effacer tous les éléments
communs aux 2 vectors, quelle serait selon vous la façon la plus
élégante de procéder?
Bonjour à tous,
je dispose de 2 std::vector, et je voudrais effacer tous les éléments
communs aux 2 vectors, quelle serait selon vous la façon la plus
élégante de procéder?
Bonjour à tous,
je dispose de 2 std::vector, et je voudrais effacer tous les éléments
communs aux 2 vectors, quelle serait selon vous la façon la plus
élégante de procéder?
On 5 oct, 17:38, Guillaume GOURDIN wrote:
> je dispose de 2 std::vector, et je voudrais effacer tous les
> éléments communs aux 2 vectors, quelle serait selon vous la
> façon la plus élégante de procéder?
l'effacer ou?
pour trouver l'intersection puis la difference
http://www.cplusplus.com/reference/algorithm/set_intersection/http://www. cplusplus.com/reference/algorithm/set_difference/
ca sera certainement plus efficace que "d'effacer" les
elements les uns apres les autres.
On 5 oct, 17:38, Guillaume GOURDIN <tr...@hotmail.com> wrote:
> je dispose de 2 std::vector, et je voudrais effacer tous les
> éléments communs aux 2 vectors, quelle serait selon vous la
> façon la plus élégante de procéder?
l'effacer ou?
pour trouver l'intersection puis la difference
http://www.cplusplus.com/reference/algorithm/set_intersection/http://www. cplusplus.com/reference/algorithm/set_difference/
ca sera certainement plus efficace que "d'effacer" les
elements les uns apres les autres.
On 5 oct, 17:38, Guillaume GOURDIN wrote:
> je dispose de 2 std::vector, et je voudrais effacer tous les
> éléments communs aux 2 vectors, quelle serait selon vous la
> façon la plus élégante de procéder?
l'effacer ou?
pour trouver l'intersection puis la difference
http://www.cplusplus.com/reference/algorithm/set_intersection/http://www. cplusplus.com/reference/algorithm/set_difference/
ca sera certainement plus efficace que "d'effacer" les
elements les uns apres les autres.
On Oct 5, 6:37 pm, ld wrote:
> On 5 oct, 17:38, Guillaume GOURDIN wrote:
> > je dispose de 2 std::vector, et je voudrais effacer tous les
> > éléments communs aux 2 vectors, quelle serait selon vous la
> > façon la plus élégante de procéder?
> l'effacer ou?
> pour trouver l'intersection puis la difference
>http://www.cplusplus.com/reference/algorithm/set_intersection/http://...
> ca sera certainement plus efficace que "d'effacer" les
> elements les uns apres les autres.
Note bien que ces algorithmes exigent que les vector soit trié.
a.erase( std::remove_if( a.begin(), a.end(),
isMemberOf( b. begin(), b.end() ) ),
a.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a. begin(), a.end() ) ),
b.end() ) ;
Simple et élégant (AMA, en tout cas), mais comme j'ai dit,
O(n^2).
On Oct 5, 6:37 pm, ld <laurent.den...@gmail.com> wrote:
> On 5 oct, 17:38, Guillaume GOURDIN <tr...@hotmail.com> wrote:
> > je dispose de 2 std::vector, et je voudrais effacer tous les
> > éléments communs aux 2 vectors, quelle serait selon vous la
> > façon la plus élégante de procéder?
> l'effacer ou?
> pour trouver l'intersection puis la difference
>http://www.cplusplus.com/reference/algorithm/set_intersection/http://...
> ca sera certainement plus efficace que "d'effacer" les
> elements les uns apres les autres.
Note bien que ces algorithmes exigent que les vector soit trié.
a.erase( std::remove_if( a.begin(), a.end(),
isMemberOf( b. begin(), b.end() ) ),
a.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a. begin(), a.end() ) ),
b.end() ) ;
Simple et élégant (AMA, en tout cas), mais comme j'ai dit,
O(n^2).
On Oct 5, 6:37 pm, ld wrote:
> On 5 oct, 17:38, Guillaume GOURDIN wrote:
> > je dispose de 2 std::vector, et je voudrais effacer tous les
> > éléments communs aux 2 vectors, quelle serait selon vous la
> > façon la plus élégante de procéder?
> l'effacer ou?
> pour trouver l'intersection puis la difference
>http://www.cplusplus.com/reference/algorithm/set_intersection/http://...
> ca sera certainement plus efficace que "d'effacer" les
> elements les uns apres les autres.
Note bien que ces algorithmes exigent que les vector soit trié.
a.erase( std::remove_if( a.begin(), a.end(),
isMemberOf( b. begin(), b.end() ) ),
a.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a. begin(), a.end() ) ),
b.end() ) ;
Simple et élégant (AMA, en tout cas), mais comme j'ai dit,
O(n^2).
Si les vector ne sont pas triés, les algorithmes qui me viennent
à l'ésprit sont tous O(n^2) ; ils ne conviennent donc qu'à des
petits vectors. Mais si les vector ne sont pas trop gros, il ne
doit pas être difficile à concevoir un prédicat du genre,
isElementOf (qui se servira de std::find), puis se servir de
std::remove. Ensuite, on enlève de a tous les éléments de b, et
vice versa. Quelque chose du genre :
puis:
a.erase( std::remove_if( a.begin(), a.end(),
isMemberOf( b.begin(), b.end() ) ),
a.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a.begin(), a.end() ) ),
b.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a.begin(), a.end() ) ),
b.end() ) ;
Si les vector ne sont pas triés, les algorithmes qui me viennent
à l'ésprit sont tous O(n^2) ; ils ne conviennent donc qu'à des
petits vectors. Mais si les vector ne sont pas trop gros, il ne
doit pas être difficile à concevoir un prédicat du genre,
isElementOf (qui se servira de std::find), puis se servir de
std::remove. Ensuite, on enlève de a tous les éléments de b, et
vice versa. Quelque chose du genre :
puis:
a.erase( std::remove_if( a.begin(), a.end(),
isMemberOf( b.begin(), b.end() ) ),
a.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a.begin(), a.end() ) ),
b.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a.begin(), a.end() ) ),
b.end() ) ;
Si les vector ne sont pas triés, les algorithmes qui me viennent
à l'ésprit sont tous O(n^2) ; ils ne conviennent donc qu'à des
petits vectors. Mais si les vector ne sont pas trop gros, il ne
doit pas être difficile à concevoir un prédicat du genre,
isElementOf (qui se servira de std::find), puis se servir de
std::remove. Ensuite, on enlève de a tous les éléments de b, et
vice versa. Quelque chose du genre :
puis:
a.erase( std::remove_if( a.begin(), a.end(),
isMemberOf( b.begin(), b.end() ) ),
a.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a.begin(), a.end() ) ),
b.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a.begin(), a.end() ) ),
b.end() ) ;
si les deux éléments sont égaux, on les enlève tous les deux,
while ( a_iter != a.end() && b_iter != b.end() ) {
if ( *a_iter < *b_iter ) {
++ a_iter ;
} else if ( *b_iter < *a_iter ) {
++ b_iter ;
} else {
a_iter = a.erase( a_iter ) ;
b_iter = b.erase( b_iter ) ;
}
}
a.erase( std::remove_if( a.begin(), a.end(),
isMemberOf( b.begin(), b.end() ) ),
a.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a.begin(), a.end() ) ),
b.end() ) ;
si les deux éléments sont égaux, on les enlève tous les deux,
while ( a_iter != a.end() && b_iter != b.end() ) {
if ( *a_iter < *b_iter ) {
++ a_iter ;
} else if ( *b_iter < *a_iter ) {
++ b_iter ;
} else {
a_iter = a.erase( a_iter ) ;
b_iter = b.erase( b_iter ) ;
}
}
a.erase( std::remove_if( a.begin(), a.end(),
isMemberOf( b.begin(), b.end() ) ),
a.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a.begin(), a.end() ) ),
b.end() ) ;
si les deux éléments sont égaux, on les enlève tous les deux,
while ( a_iter != a.end() && b_iter != b.end() ) {
if ( *a_iter < *b_iter ) {
++ a_iter ;
} else if ( *b_iter < *a_iter ) {
++ b_iter ;
} else {
a_iter = a.erase( a_iter ) ;
b_iter = b.erase( b_iter ) ;
}
}
a.erase( std::remove_if( a.begin(), a.end(),
isMemberOf( b.begin(), b.end() ) ),
a.end() ) ;
b.erase( std::remove_if( b.begin(), b.end(),
isMemberOf( a.begin(), a.end() ) ),
b.end() ) ;
Le 7 octobre 2009, James Kanze a écrit :
> si les deux éléments sont égaux, on les enlève tous les deux,
> while ( a_iter != a.end() && b_iter != b.end() ) {
> if ( *a_iter < *b_iter ) {
> ++ a_iter ;
> } else if ( *b_iter < *a_iter ) {
> ++ b_iter ;
> } else {
> a_iter = a.erase( a_iter ) ;
> b_iter = b.erase( b_iter ) ;
> }
> }
Et s'il y a un doublon dans a ou dans b ?
> a.erase( std::remove_if( a.begin(), a.end(),
> isMemberOf( b.begin(), b.end() ) ),
> a.end() ) ;
> b.erase( std::remove_if( b.begin(), b.end(),
> isMemberOf( a.begin(), a.end() ) ),
> b.end() ) ;
Je ne maîtrise pas assez pour être sûr d'avoir bien compris,
mais il me semble que dans la première étape tu enlèves du
vecteur a les éléments qu'on trouve dans b, du coup dans la
seconde étape tu ne pourras pas les enlever de b car ils ne
seront plus « MemberOf » a...
Le 7 octobre 2009, James Kanze a écrit :
> si les deux éléments sont égaux, on les enlève tous les deux,
> while ( a_iter != a.end() && b_iter != b.end() ) {
> if ( *a_iter < *b_iter ) {
> ++ a_iter ;
> } else if ( *b_iter < *a_iter ) {
> ++ b_iter ;
> } else {
> a_iter = a.erase( a_iter ) ;
> b_iter = b.erase( b_iter ) ;
> }
> }
Et s'il y a un doublon dans a ou dans b ?
> a.erase( std::remove_if( a.begin(), a.end(),
> isMemberOf( b.begin(), b.end() ) ),
> a.end() ) ;
> b.erase( std::remove_if( b.begin(), b.end(),
> isMemberOf( a.begin(), a.end() ) ),
> b.end() ) ;
Je ne maîtrise pas assez pour être sûr d'avoir bien compris,
mais il me semble que dans la première étape tu enlèves du
vecteur a les éléments qu'on trouve dans b, du coup dans la
seconde étape tu ne pourras pas les enlever de b car ils ne
seront plus « MemberOf » a...
Le 7 octobre 2009, James Kanze a écrit :
> si les deux éléments sont égaux, on les enlève tous les deux,
> while ( a_iter != a.end() && b_iter != b.end() ) {
> if ( *a_iter < *b_iter ) {
> ++ a_iter ;
> } else if ( *b_iter < *a_iter ) {
> ++ b_iter ;
> } else {
> a_iter = a.erase( a_iter ) ;
> b_iter = b.erase( b_iter ) ;
> }
> }
Et s'il y a un doublon dans a ou dans b ?
> a.erase( std::remove_if( a.begin(), a.end(),
> isMemberOf( b.begin(), b.end() ) ),
> a.end() ) ;
> b.erase( std::remove_if( b.begin(), b.end(),
> isMemberOf( a.begin(), a.end() ) ),
> b.end() ) ;
Je ne maîtrise pas assez pour être sûr d'avoir bien compris,
mais il me semble que dans la première étape tu enlèves du
vecteur a les éléments qu'on trouve dans b, du coup dans la
seconde étape tu ne pourras pas les enlever de b car ils ne
seront plus « MemberOf » a...
On Oct 8, 10:28 am, Lucas Levrel wrote:
> Le 7 octobre 2009, James Kanze a écrit :
> > si les deux éléments sont égaux, on les enlève tous les deux,
> > while ( a_iter != a.end() && b_iter != b.end() ) {
> > if ( *a_iter < *b_iter ) {
> > ++ a_iter ;
> > } else if ( *b_iter < *a_iter ) {
> > ++ b_iter ;
> > } else {
> > a_iter = a.erase( a_iter ) ;
> > b_iter = b.erase( b_iter ) ;
> > }
> > }
> Et s'il y a un doublon dans a ou dans b ?
Je ne vois pas ce que ça changerait.
On Oct 8, 10:28 am, Lucas Levrel <lucas.lev...@univ-paris12.fr> wrote:
> Le 7 octobre 2009, James Kanze a écrit :
> > si les deux éléments sont égaux, on les enlève tous les deux,
> > while ( a_iter != a.end() && b_iter != b.end() ) {
> > if ( *a_iter < *b_iter ) {
> > ++ a_iter ;
> > } else if ( *b_iter < *a_iter ) {
> > ++ b_iter ;
> > } else {
> > a_iter = a.erase( a_iter ) ;
> > b_iter = b.erase( b_iter ) ;
> > }
> > }
> Et s'il y a un doublon dans a ou dans b ?
Je ne vois pas ce que ça changerait.
On Oct 8, 10:28 am, Lucas Levrel wrote:
> Le 7 octobre 2009, James Kanze a écrit :
> > si les deux éléments sont égaux, on les enlève tous les deux,
> > while ( a_iter != a.end() && b_iter != b.end() ) {
> > if ( *a_iter < *b_iter ) {
> > ++ a_iter ;
> > } else if ( *b_iter < *a_iter ) {
> > ++ b_iter ;
> > } else {
> > a_iter = a.erase( a_iter ) ;
> > b_iter = b.erase( b_iter ) ;
> > }
> > }
> Et s'il y a un doublon dans a ou dans b ?
Je ne vois pas ce que ça changerait.
Le 8 octobre 2009, James Kanze a écrit :
> On Oct 8, 10:28 am, Lucas Levrel wrote:
> > Le 7 octobre 2009, James Kanze a écrit :
> > > si les deux éléments sont égaux, on les enlève tous les deu x,
> > > while ( a_iter != a.end() && b_iter != b.end() ) {
> > > if ( *a_iter < *b_iter ) {
> > > ++ a_iter ;
> > > } else if ( *b_iter < *a_iter ) {
> > > ++ b_iter ;
> > > } else {
> > > a_iter = a.erase( a_iter ) ;
> > > b_iter = b.erase( b_iter ) ;
> > > }
> > > }
> > Et s'il y a un doublon dans a ou dans b ?
> Je ne vois pas ce que ça changerait.
Si a = (1, 2, 2, 3) et b= (0, 2, 4) il me semble que ton code aboutit à
a = (1, 2, 3) et b = (0, 4) alors qu'on veut (il me semble aussi) obt enir
a = (1, 3) et b = (0, 4).
Le 8 octobre 2009, James Kanze a écrit :
> On Oct 8, 10:28 am, Lucas Levrel <lucas.lev...@univ-paris12.fr> wrote:
> > Le 7 octobre 2009, James Kanze a écrit :
> > > si les deux éléments sont égaux, on les enlève tous les deu x,
> > > while ( a_iter != a.end() && b_iter != b.end() ) {
> > > if ( *a_iter < *b_iter ) {
> > > ++ a_iter ;
> > > } else if ( *b_iter < *a_iter ) {
> > > ++ b_iter ;
> > > } else {
> > > a_iter = a.erase( a_iter ) ;
> > > b_iter = b.erase( b_iter ) ;
> > > }
> > > }
> > Et s'il y a un doublon dans a ou dans b ?
> Je ne vois pas ce que ça changerait.
Si a = (1, 2, 2, 3) et b= (0, 2, 4) il me semble que ton code aboutit à
a = (1, 2, 3) et b = (0, 4) alors qu'on veut (il me semble aussi) obt enir
a = (1, 3) et b = (0, 4).
Le 8 octobre 2009, James Kanze a écrit :
> On Oct 8, 10:28 am, Lucas Levrel wrote:
> > Le 7 octobre 2009, James Kanze a écrit :
> > > si les deux éléments sont égaux, on les enlève tous les deu x,
> > > while ( a_iter != a.end() && b_iter != b.end() ) {
> > > if ( *a_iter < *b_iter ) {
> > > ++ a_iter ;
> > > } else if ( *b_iter < *a_iter ) {
> > > ++ b_iter ;
> > > } else {
> > > a_iter = a.erase( a_iter ) ;
> > > b_iter = b.erase( b_iter ) ;
> > > }
> > > }
> > Et s'il y a un doublon dans a ou dans b ?
> Je ne vois pas ce que ça changerait.
Si a = (1, 2, 2, 3) et b= (0, 2, 4) il me semble que ton code aboutit à
a = (1, 2, 3) et b = (0, 4) alors qu'on veut (il me semble aussi) obt enir
a = (1, 3) et b = (0, 4).