Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les mouvements de
la colonne aout à celle de septembre comme suit:
aout septembre
90000301 90000301
90001010 90001010
90001074 90001074
90001079 90001079
90001081 90001081
90001086 90001085
90001090 90001086
90001091 90001090
90001092 90001091
90001098 90001092 1 sortie
dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
milliers de codes en plus dans la colonne de septembre par rapport à celle
de aout
si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
combien d'entrée de nouveau code et combien de sortie d'ancien code et
idéalement la liste des codes entrants et sortants
Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les mouvements de
la colonne aout à celle de septembre comme suit:
aout septembre
90000301 90000301
90001010 90001010
90001074 90001074
90001079 90001079
90001081 90001081
90001086 90001085
90001090 90001086
90001091 90001090
90001092 90001091
90001098 90001092 1 sortie
dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
milliers de codes en plus dans la colonne de septembre par rapport à celle
de aout
si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
combien d'entrée de nouveau code et combien de sortie d'ancien code et
idéalement la liste des codes entrants et sortants
Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les mouvements de
la colonne aout à celle de septembre comme suit:
aout septembre
90000301 90000301
90001010 90001010
90001074 90001074
90001079 90001079
90001081 90001081
90001086 90001085
90001090 90001086
90001091 90001090
90001092 90001091
90001098 90001092 1 sortie
dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
milliers de codes en plus dans la colonne de septembre par rapport à celle
de aout
si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
combien d'entrée de nouveau code et combien de sortie d'ancien code et
idéalement la liste des codes entrants et sortants
"Vincent_C" a écrit dans le message de
news:
> Bonjour,
>
> Sur une liste en 2 colonnes. je souhaiterais
> identifier toutes les entrées et sorties qui constituent les mouvements de
> la colonne aout à celle de septembre comme suit:
>
> aout septembre
> 90000301 90000301
> 90001010 90001010
> 90001074 90001074
> 90001079 90001079
> 90001081 90001081
> 90001086 90001085
> 90001090 90001086
> 90001091 90001090
> 90001092 90001091
> 90001098 90001092 1 sortie
>
> dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
> sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
> milliers de codes en plus dans la colonne de septembre par rapport à celle
> de aout
>
> si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
> combien d'entrée de nouveau code et combien de sortie d'ancien code et
> idéalement la liste des codes entrants et sortants
Hello,
Le problème n'est pas compliqué en soi. Peux tu préciser sous quelle forme
se présentent les listes? Dans des fichiers séparés? dans le même fichier?
Si tu donnes ces précisions, il sera simple de te donner un exemple.
Sinon, l'algorithme est très simple à implémenter.
Il faudrait aussi avoir une idée du nombre de données pour les 2 mois
considérés. Un algorithme médiocre (en O(n²)) sera suffisant si il n'y a
que quelques milliers de codes, mais il faudra être plus subtil si il
y a significativement plus de données.
L'idée de base:
On range toutes les données de Aout dans un tableau.
Puis pour chauqe donnée de septembre, on la cherche dans ce tableau.
Si on la trouve, on la supprime de Aout (ce n'est ni une entrée ni une
sortie)
Si on ne la trouve pas, on stcoke cette valeur dans un second tableau
(entrées de Septembre).
A la fin, il reste dans le tableau Aout les sorties, et dans le tableau de
Septembre,
les entrées.
Si il y a peu de données, on fera une recherche brutale.
Si il y a bcp de données, on triera le tableau Aout pour y effectuer une
recherche dichotomique, ce qui nous ramenera à un algorithme en O(Log.n).
On pourra même faire encore mieux en testant très rapidement si l'entré à
considérer n'est pas
plus grande que la plus grande entrée de Aout ec qui évite une recherche.
Espérant que cela t'aide,
--
Jean-marc Noury
MVP Visual Basic
mailto: remove '_no_spam_' ;
FAQ VB: http://faq.vb.free.fr/
bonjour Jean Marc,
"Vincent_C" <VincentC@discussions.microsoft.com> a écrit dans le message de
news: 85F995AE-7397-4E18-BC86-06D960BE58E8@microsoft.com...
> Bonjour,
>
> Sur une liste en 2 colonnes. je souhaiterais
> identifier toutes les entrées et sorties qui constituent les mouvements de
> la colonne aout à celle de septembre comme suit:
>
> aout septembre
> 90000301 90000301
> 90001010 90001010
> 90001074 90001074
> 90001079 90001079
> 90001081 90001081
> 90001086 90001085
> 90001090 90001086
> 90001091 90001090
> 90001092 90001091
> 90001098 90001092 1 sortie
>
> dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
> sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
> milliers de codes en plus dans la colonne de septembre par rapport à celle
> de aout
>
> si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
> combien d'entrée de nouveau code et combien de sortie d'ancien code et
> idéalement la liste des codes entrants et sortants
Hello,
Le problème n'est pas compliqué en soi. Peux tu préciser sous quelle forme
se présentent les listes? Dans des fichiers séparés? dans le même fichier?
Si tu donnes ces précisions, il sera simple de te donner un exemple.
Sinon, l'algorithme est très simple à implémenter.
Il faudrait aussi avoir une idée du nombre de données pour les 2 mois
considérés. Un algorithme médiocre (en O(n²)) sera suffisant si il n'y a
que quelques milliers de codes, mais il faudra être plus subtil si il
y a significativement plus de données.
L'idée de base:
On range toutes les données de Aout dans un tableau.
Puis pour chauqe donnée de septembre, on la cherche dans ce tableau.
Si on la trouve, on la supprime de Aout (ce n'est ni une entrée ni une
sortie)
Si on ne la trouve pas, on stcoke cette valeur dans un second tableau
(entrées de Septembre).
A la fin, il reste dans le tableau Aout les sorties, et dans le tableau de
Septembre,
les entrées.
Si il y a peu de données, on fera une recherche brutale.
Si il y a bcp de données, on triera le tableau Aout pour y effectuer une
recherche dichotomique, ce qui nous ramenera à un algorithme en O(Log.n).
On pourra même faire encore mieux en testant très rapidement si l'entré à
considérer n'est pas
plus grande que la plus grande entrée de Aout ec qui évite une recherche.
Espérant que cela t'aide,
--
Jean-marc Noury
MVP Visual Basic
mailto: remove '_no_spam_' ; _no_spam_jean_marc_n2@yahoo.fr
FAQ VB: http://faq.vb.free.fr/
bonjour Jean Marc,
"Vincent_C" a écrit dans le message de
news:
> Bonjour,
>
> Sur une liste en 2 colonnes. je souhaiterais
> identifier toutes les entrées et sorties qui constituent les mouvements de
> la colonne aout à celle de septembre comme suit:
>
> aout septembre
> 90000301 90000301
> 90001010 90001010
> 90001074 90001074
> 90001079 90001079
> 90001081 90001081
> 90001086 90001085
> 90001090 90001086
> 90001091 90001090
> 90001092 90001091
> 90001098 90001092 1 sortie
>
> dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
> sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
> milliers de codes en plus dans la colonne de septembre par rapport à celle
> de aout
>
> si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
> combien d'entrée de nouveau code et combien de sortie d'ancien code et
> idéalement la liste des codes entrants et sortants
Hello,
Le problème n'est pas compliqué en soi. Peux tu préciser sous quelle forme
se présentent les listes? Dans des fichiers séparés? dans le même fichier?
Si tu donnes ces précisions, il sera simple de te donner un exemple.
Sinon, l'algorithme est très simple à implémenter.
Il faudrait aussi avoir une idée du nombre de données pour les 2 mois
considérés. Un algorithme médiocre (en O(n²)) sera suffisant si il n'y a
que quelques milliers de codes, mais il faudra être plus subtil si il
y a significativement plus de données.
L'idée de base:
On range toutes les données de Aout dans un tableau.
Puis pour chauqe donnée de septembre, on la cherche dans ce tableau.
Si on la trouve, on la supprime de Aout (ce n'est ni une entrée ni une
sortie)
Si on ne la trouve pas, on stcoke cette valeur dans un second tableau
(entrées de Septembre).
A la fin, il reste dans le tableau Aout les sorties, et dans le tableau de
Septembre,
les entrées.
Si il y a peu de données, on fera une recherche brutale.
Si il y a bcp de données, on triera le tableau Aout pour y effectuer une
recherche dichotomique, ce qui nous ramenera à un algorithme en O(Log.n).
On pourra même faire encore mieux en testant très rapidement si l'entré à
considérer n'est pas
plus grande que la plus grande entrée de Aout ec qui évite une recherche.
Espérant que cela t'aide,
--
Jean-marc Noury
MVP Visual Basic
mailto: remove '_no_spam_' ;
FAQ VB: http://faq.vb.free.fr/
bonjour Jean Marc,
"Jean-marc" a écrit :"Vincent_C" a écrit dans le message
de
news:
> Bonjour,
>
> Sur une liste en 2 colonnes. je souhaiterais
> identifier toutes les entrées et sorties qui constituent les mouvements
> de
> la colonne aout à celle de septembre comme suit:
>
> aout septembre
> 90000301 90000301
> 90001010 90001010
> 90001074 90001074
> 90001079 90001079
> 90001081 90001081
> 90001086 90001085
> 90001090 90001086
> 90001091 90001090
> 90001092 90001091
> 90001098 90001092 1 sortie
>
> dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et
> une
> sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
> milliers de codes en plus dans la colonne de septembre par rapport à
> celle
> de aout
>
> si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais
> savoir
> combien d'entrée de nouveau code et combien de sortie d'ancien code et
> idéalement la liste des codes entrants et sortants
Hello,
Le problème n'est pas compliqué en soi. Peux tu préciser sous quelle
forme
se présentent les listes? Dans des fichiers séparés? dans le même
fichier?
Si tu donnes ces précisions, il sera simple de te donner un exemple.
Sinon, l'algorithme est très simple à implémenter.
Il faudrait aussi avoir une idée du nombre de données pour les 2 mois
considérés. Un algorithme médiocre (en O(n²)) sera suffisant si il n'y a
que quelques milliers de codes, mais il faudra être plus subtil si il
y a significativement plus de données.
L'idée de base:
On range toutes les données de Aout dans un tableau.
Puis pour chauqe donnée de septembre, on la cherche dans ce tableau.
Si on la trouve, on la supprime de Aout (ce n'est ni une entrée ni une
sortie)
Si on ne la trouve pas, on stcoke cette valeur dans un second tableau
(entrées de Septembre).
A la fin, il reste dans le tableau Aout les sorties, et dans le tableau
de
Septembre,
les entrées.
Si il y a peu de données, on fera une recherche brutale.
Si il y a bcp de données, on triera le tableau Aout pour y effectuer une
recherche dichotomique, ce qui nous ramenera à un algorithme en O(Log.n).
On pourra même faire encore mieux en testant très rapidement si l'entré à
considérer n'est pas
plus grande que la plus grande entrée de Aout ec qui évite une recherche.
Espérant que cela t'aide,
--
Jean-marc Noury
MVP Visual Basic
mailto: remove '_no_spam_' ;
FAQ VB: http://faq.vb.free.fr/
bonjour Jean Marc,
Merci pour ton message.
voici les réponses : Effectivement il y a environ 55 000 lignes de données
pour la deuxième colonne et environ 50 000 pour la première ; il s'agit de
2
colonnes juxtaposée dans un même onglet de fichier Excel.
"Jean-marc" a écrit :
"Vincent_C" <VincentC@discussions.microsoft.com> a écrit dans le message
de
news: 85F995AE-7397-4E18-BC86-06D960BE58E8@microsoft.com...
> Bonjour,
>
> Sur une liste en 2 colonnes. je souhaiterais
> identifier toutes les entrées et sorties qui constituent les mouvements
> de
> la colonne aout à celle de septembre comme suit:
>
> aout septembre
> 90000301 90000301
> 90001010 90001010
> 90001074 90001074
> 90001079 90001079
> 90001081 90001081
> 90001086 90001085
> 90001090 90001086
> 90001091 90001090
> 90001092 90001091
> 90001098 90001092 1 sortie
>
> dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et
> une
> sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
> milliers de codes en plus dans la colonne de septembre par rapport à
> celle
> de aout
>
> si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais
> savoir
> combien d'entrée de nouveau code et combien de sortie d'ancien code et
> idéalement la liste des codes entrants et sortants
Hello,
Le problème n'est pas compliqué en soi. Peux tu préciser sous quelle
forme
se présentent les listes? Dans des fichiers séparés? dans le même
fichier?
Si tu donnes ces précisions, il sera simple de te donner un exemple.
Sinon, l'algorithme est très simple à implémenter.
Il faudrait aussi avoir une idée du nombre de données pour les 2 mois
considérés. Un algorithme médiocre (en O(n²)) sera suffisant si il n'y a
que quelques milliers de codes, mais il faudra être plus subtil si il
y a significativement plus de données.
L'idée de base:
On range toutes les données de Aout dans un tableau.
Puis pour chauqe donnée de septembre, on la cherche dans ce tableau.
Si on la trouve, on la supprime de Aout (ce n'est ni une entrée ni une
sortie)
Si on ne la trouve pas, on stcoke cette valeur dans un second tableau
(entrées de Septembre).
A la fin, il reste dans le tableau Aout les sorties, et dans le tableau
de
Septembre,
les entrées.
Si il y a peu de données, on fera une recherche brutale.
Si il y a bcp de données, on triera le tableau Aout pour y effectuer une
recherche dichotomique, ce qui nous ramenera à un algorithme en O(Log.n).
On pourra même faire encore mieux en testant très rapidement si l'entré à
considérer n'est pas
plus grande que la plus grande entrée de Aout ec qui évite une recherche.
Espérant que cela t'aide,
--
Jean-marc Noury
MVP Visual Basic
mailto: remove '_no_spam_' ; _no_spam_jean_marc_n2@yahoo.fr
FAQ VB: http://faq.vb.free.fr/
bonjour Jean Marc,
Merci pour ton message.
voici les réponses : Effectivement il y a environ 55 000 lignes de données
pour la deuxième colonne et environ 50 000 pour la première ; il s'agit de
2
colonnes juxtaposée dans un même onglet de fichier Excel.
"Jean-marc" a écrit :"Vincent_C" a écrit dans le message
de
news:
> Bonjour,
>
> Sur une liste en 2 colonnes. je souhaiterais
> identifier toutes les entrées et sorties qui constituent les mouvements
> de
> la colonne aout à celle de septembre comme suit:
>
> aout septembre
> 90000301 90000301
> 90001010 90001010
> 90001074 90001074
> 90001079 90001079
> 90001081 90001081
> 90001086 90001085
> 90001090 90001086
> 90001091 90001090
> 90001092 90001091
> 90001098 90001092 1 sortie
>
> dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et
> une
> sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
> milliers de codes en plus dans la colonne de septembre par rapport à
> celle
> de aout
>
> si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais
> savoir
> combien d'entrée de nouveau code et combien de sortie d'ancien code et
> idéalement la liste des codes entrants et sortants
Hello,
Le problème n'est pas compliqué en soi. Peux tu préciser sous quelle
forme
se présentent les listes? Dans des fichiers séparés? dans le même
fichier?
Si tu donnes ces précisions, il sera simple de te donner un exemple.
Sinon, l'algorithme est très simple à implémenter.
Il faudrait aussi avoir une idée du nombre de données pour les 2 mois
considérés. Un algorithme médiocre (en O(n²)) sera suffisant si il n'y a
que quelques milliers de codes, mais il faudra être plus subtil si il
y a significativement plus de données.
L'idée de base:
On range toutes les données de Aout dans un tableau.
Puis pour chauqe donnée de septembre, on la cherche dans ce tableau.
Si on la trouve, on la supprime de Aout (ce n'est ni une entrée ni une
sortie)
Si on ne la trouve pas, on stcoke cette valeur dans un second tableau
(entrées de Septembre).
A la fin, il reste dans le tableau Aout les sorties, et dans le tableau
de
Septembre,
les entrées.
Si il y a peu de données, on fera une recherche brutale.
Si il y a bcp de données, on triera le tableau Aout pour y effectuer une
recherche dichotomique, ce qui nous ramenera à un algorithme en O(Log.n).
On pourra même faire encore mieux en testant très rapidement si l'entré à
considérer n'est pas
plus grande que la plus grande entrée de Aout ec qui évite une recherche.
Espérant que cela t'aide,
--
Jean-marc Noury
MVP Visual Basic
mailto: remove '_no_spam_' ;
FAQ VB: http://faq.vb.free.fr/
bonjour Jean Marc,
Merci pour ton message.
voici les réponses : Effectivement il y a environ 55 000 lignes de données
pour la deuxième colonne et environ 50 000 pour la première ; il s'agit de
2
colonnes juxtaposée dans un même onglet de fichier Excel.
Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les mouvements de
la colonne aout à celle de septembre comme suit:
aout septembre
90000301 90000301
90001010 90001010
90001074 90001074
90001079 90001079
90001081 90001081
90001086 90001085
90001090 90001086
90001091 90001090
90001092 90001091
90001098 90001092 1 sortie
dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
milliers de codes en plus dans la colonne de septembre par rapport à celle
de aout
si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
combien d'entrée de nouveau code et combien de sortie d'ancien code et
idéalement la liste des codes entrants et sortants
merci !
Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les mouvements de
la colonne aout à celle de septembre comme suit:
aout septembre
90000301 90000301
90001010 90001010
90001074 90001074
90001079 90001079
90001081 90001081
90001086 90001085
90001090 90001086
90001091 90001090
90001092 90001091
90001098 90001092 1 sortie
dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
milliers de codes en plus dans la colonne de septembre par rapport à celle
de aout
si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
combien d'entrée de nouveau code et combien de sortie d'ancien code et
idéalement la liste des codes entrants et sortants
merci !
Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les mouvements de
la colonne aout à celle de septembre comme suit:
aout septembre
90000301 90000301
90001010 90001010
90001074 90001074
90001079 90001079
90001081 90001081
90001086 90001085
90001090 90001086
90001091 90001090
90001092 90001091
90001098 90001092 1 sortie
dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
milliers de codes en plus dans la colonne de septembre par rapport à celle
de aout
si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
combien d'entrée de nouveau code et combien de sortie d'ancien code et
idéalement la liste des codes entrants et sortants
merci !
Bonjour,
Heu, juste une précision, si tu parles de l'objet "list", il avale
32.000 lignes, et toi tu parles de 45.000 lignes (entrées)... Le pointeur
(index) va devenir négatif, etc, ce n'est pas gérable comme ça avec une
quantité > 32.000 et quelques...
--
Merci beaucoup, au revoir et à bientôt :o)
------
Site ROMANS édités
http://www.manuscritdepot.com/a.joseph-attila-pusztay.1.htm
Site LOGICIELS
http://irolog.free.fr
http://irolog.free.fr/ecrire/index.htm
------------------------------------------------------------------------------------
"Vincent_C" a écrit dans le message
de news:Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les mouvements
de
la colonne aout à celle de septembre comme suit:
aout septembre
90000301 90000301
90001010 90001010
90001074 90001074
90001079 90001079
90001081 90001081
90001086 90001085
90001090 90001086
90001091 90001090
90001092 90001091
90001098 90001092 1 sortie
dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
milliers de codes en plus dans la colonne de septembre par rapport à
celle
de aout
si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
combien d'entrée de nouveau code et combien de sortie d'ancien code et
idéalement la liste des codes entrants et sortants
merci !
Bonjour,
Heu, juste une précision, si tu parles de l'objet "list", il avale
32.000 lignes, et toi tu parles de 45.000 lignes (entrées)... Le pointeur
(index) va devenir négatif, etc, ce n'est pas gérable comme ça avec une
quantité > 32.000 et quelques...
--
Merci beaucoup, au revoir et à bientôt :o)
------
Site ROMANS édités
http://www.manuscritdepot.com/a.joseph-attila-pusztay.1.htm
Site LOGICIELS
http://irolog.free.fr
http://irolog.free.fr/ecrire/index.htm
------------------------------------------------------------------------------------
"Vincent_C" <VincentC@discussions.microsoft.com> a écrit dans le message
de news: 85F995AE-7397-4E18-BC86-06D960BE58E8@microsoft.com...
Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les mouvements
de
la colonne aout à celle de septembre comme suit:
aout septembre
90000301 90000301
90001010 90001010
90001074 90001074
90001079 90001079
90001081 90001081
90001086 90001085
90001090 90001086
90001091 90001090
90001092 90001091
90001098 90001092 1 sortie
dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
milliers de codes en plus dans la colonne de septembre par rapport à
celle
de aout
si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
combien d'entrée de nouveau code et combien de sortie d'ancien code et
idéalement la liste des codes entrants et sortants
merci !
Bonjour,
Heu, juste une précision, si tu parles de l'objet "list", il avale
32.000 lignes, et toi tu parles de 45.000 lignes (entrées)... Le pointeur
(index) va devenir négatif, etc, ce n'est pas gérable comme ça avec une
quantité > 32.000 et quelques...
--
Merci beaucoup, au revoir et à bientôt :o)
------
Site ROMANS édités
http://www.manuscritdepot.com/a.joseph-attila-pusztay.1.htm
Site LOGICIELS
http://irolog.free.fr
http://irolog.free.fr/ecrire/index.htm
------------------------------------------------------------------------------------
"Vincent_C" a écrit dans le message
de news:Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les mouvements
de
la colonne aout à celle de septembre comme suit:
aout septembre
90000301 90000301
90001010 90001010
90001074 90001074
90001079 90001079
90001081 90001081
90001086 90001085
90001090 90001086
90001091 90001090
90001092 90001091
90001098 90001092 1 sortie
dans l'exemple sur 10 lignes nous avons une entrée (code 90001085) et une
sortie (90001098). dans la réalité de ce que je cherche il y a +ieurs
milliers de codes en plus dans la colonne de septembre par rapport à
celle
de aout
si en aout il y a 30 000 codes et en septembre 45 000, j'aimerais savoir
combien d'entrée de nouveau code et combien de sortie d'ancien code et
idéalement la liste des codes entrants et sortants
merci !
Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les
mouvements de la colonne aout à celle de septembre comme suit:
Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les
mouvements de la colonne aout à celle de septembre comme suit:
Bonjour,
Sur une liste en 2 colonnes. je souhaiterais
identifier toutes les entrées et sorties qui constituent les
mouvements de la colonne aout à celle de septembre comme suit:
Dans : news:
Vincent_C écrit :
> Bonjour,
Bonjour,
> Sur une liste en 2 colonnes. je souhaiterais
> identifier toutes les entrées et sorties qui constituent les
> mouvements de la colonne aout à celle de septembre comme suit:
[...]
Puisqu'il semble que tes colonnes sont triées, l'algorithme suivant
devrait faire l'affaire:
Dim i As Long
Dim j As Long
Dim e As Long
Dim s As Long
i = 2
j = 2
e = 2
s = 2
While ActiveSheet.Cells(i, 1).Value <> "" Or ActiveSheet.Cells(j,
2).Value <> ""
If ActiveSheet.Cells(i, 1) = ActiveSheet.Cells(j, 2) Then
i = i + 1
j = j + 1
Else
If ActiveSheet.Cells(i, 1).Value < ActiveSheet.Cells(j, 2).Value
Then
ActiveSheet.Cells(s, 4).Value = ActiveSheet.Cells(i, 1)
i = i + 1
s = s + 1
Else
ActiveSheet.Cells(e, 3).Value = ActiveSheet.Cells(j,
2).Value
j = j + 1
e = e + 1
End If
End If
Wend
Je supppose que les données d'Août sont en colonne 1, celles de
septembre en colonne 2.
Elles débutent à la ligne 2.
En fin de traitement, les sorties figurent en colonne 4 et les entrées
en colonne 3.
--
Fred
http://www.cerbermail.com/?3kA6ftaCvT
Dans : news:85F995AE-7397-4E18-BC86-06D960BE58E8@microsoft.com
Vincent_C écrit :
> Bonjour,
Bonjour,
> Sur une liste en 2 colonnes. je souhaiterais
> identifier toutes les entrées et sorties qui constituent les
> mouvements de la colonne aout à celle de septembre comme suit:
[...]
Puisqu'il semble que tes colonnes sont triées, l'algorithme suivant
devrait faire l'affaire:
Dim i As Long
Dim j As Long
Dim e As Long
Dim s As Long
i = 2
j = 2
e = 2
s = 2
While ActiveSheet.Cells(i, 1).Value <> "" Or ActiveSheet.Cells(j,
2).Value <> ""
If ActiveSheet.Cells(i, 1) = ActiveSheet.Cells(j, 2) Then
i = i + 1
j = j + 1
Else
If ActiveSheet.Cells(i, 1).Value < ActiveSheet.Cells(j, 2).Value
Then
ActiveSheet.Cells(s, 4).Value = ActiveSheet.Cells(i, 1)
i = i + 1
s = s + 1
Else
ActiveSheet.Cells(e, 3).Value = ActiveSheet.Cells(j,
2).Value
j = j + 1
e = e + 1
End If
End If
Wend
Je supppose que les données d'Août sont en colonne 1, celles de
septembre en colonne 2.
Elles débutent à la ligne 2.
En fin de traitement, les sorties figurent en colonne 4 et les entrées
en colonne 3.
--
Fred
http://www.cerbermail.com/?3kA6ftaCvT
Dans : news:
Vincent_C écrit :
> Bonjour,
Bonjour,
> Sur une liste en 2 colonnes. je souhaiterais
> identifier toutes les entrées et sorties qui constituent les
> mouvements de la colonne aout à celle de septembre comme suit:
[...]
Puisqu'il semble que tes colonnes sont triées, l'algorithme suivant
devrait faire l'affaire:
Dim i As Long
Dim j As Long
Dim e As Long
Dim s As Long
i = 2
j = 2
e = 2
s = 2
While ActiveSheet.Cells(i, 1).Value <> "" Or ActiveSheet.Cells(j,
2).Value <> ""
If ActiveSheet.Cells(i, 1) = ActiveSheet.Cells(j, 2) Then
i = i + 1
j = j + 1
Else
If ActiveSheet.Cells(i, 1).Value < ActiveSheet.Cells(j, 2).Value
Then
ActiveSheet.Cells(s, 4).Value = ActiveSheet.Cells(i, 1)
i = i + 1
s = s + 1
Else
ActiveSheet.Cells(e, 3).Value = ActiveSheet.Cells(j,
2).Value
j = j + 1
e = e + 1
End If
End If
Wend
Je supppose que les données d'Août sont en colonne 1, celles de
septembre en colonne 2.
Elles débutent à la ligne 2.
En fin de traitement, les sorties figurent en colonne 4 et les entrées
en colonne 3.
--
Fred
http://www.cerbermail.com/?3kA6ftaCvT