Discussion :

[Pg043]

Bonjour à toute la communauté,

Je cherche un algorithme capable de supprimer des valeurs consécutives (mais pas égales) dans un vector.

Par exemple, j'ai le vecteur contenant les valeurs suivantes :

1 2 3 4 6 7 9 11 14 15 36 37 38 39 40

Je veux obtenir le vecteur suivant

2 6 9 11 14 38

En gros, conserver la valeur du milieu pour toutes les valeurs consécutives (ex: on conserve le 38 dans les valeurs 36 37 38 39 40)

Je suis libre d'utiliser un vector ou une list. Je connais la fonction unique d'une list mais je pense pas que je puisse m'en servir dans mon cas

Merci d'avance pour votre aide

[LittleWhite]

rapidement un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
 
for ( int i = 0 ; i < taille_de_la_liste ; )
{
	for ( int j = i ; j < taille_de_la_liste-1 && liste[j]+1 == liste[j+1] ; j++ )
		{;}
	new_liste.push_back(liste[i+j/2]);
	i+=j;
}

*

Très rapidement
liste ... c'est la liste de base.
new_liste sera la nouvelle
( mon algo marcherai facilement sur les vector ... c'est juste que j'ai pas donné de bon nom au variable )

Pour expliquer , tu fais une boucle pour parcourir tout le tableau
Une boucle dans la boucle précedente pour compter le nombre d'élément successifs ( la je triche un peu , je regarde dans les tests de la boucle si y a la continuité des éléments ( successivité ... )
Donc j devient le nombre d'élément successifs.
Et je place dans ma nouvelle liste , l'element du milieur , grace à la division.

Par contre mon truc , n'est pas bug proof , c'est une conception à la volée pour te donner une idée ...

Hope this help

[3DArchi]

A mon avis, tu pourrais passer par un algo de copie avec un itérateur boost de type filter. Le seul hic c'est que tu dois pouvoir faire des aller/retour sur ton itérateur de base pour pouvoir 'aller voir' le(s) suivant(s) et déterminer le milieu.

[r0d]

Pour ma part, j'opterais pour une solution en 3 étapes simples (sans boost car visiblement, il s'agit d'un exercice):

0. trier le tableau initial (si ce n'est pas déjà fait) en utilisant, par exemple, la fonction sort() de l'en-tête <algorithm>.

1. découper ton tableau de départ en sous-tableaux (en utilisant un vector<vector<int>>) d'éléments connexes. Dans l'exemple du PO, ça donnerait 6 sous-tableaux:
1 2 3 4
6 7
9
11
14 15
36 37 38 39 40

2. Pour chaque sous-tableau, choisir un élément et l'ajouter dans un tableau résultat.

Etant donné que cela ressemble fort à un exercice, je m'abstiendrai de fournir un code fonctionnel

[Pg043]

Merci à tous pour vos réponses.

Pour lever l'ambigüité, il ne s'agit pas d'un exercice, mais c'est un cas concret dans un de mes projets. J'avais sensiblement simplifier l'affaire pour mieux expliquer mon problème.

Je vais essayer tout ca, merci encore

[3DArchi]

A mon avis, tu pourrais passer par un algo de copie avec un itérateur boost de type filter. Le seul hic c'est que tu dois pouvoir faire des aller/retour sur ton itérateur de base pour pouvoir 'aller voir' le(s) suivant(s) et déterminer le milieu.

En fait, un filter iterator ne conviendra pas. Mais tu peux quand même regarder du côté de Boost.Iterator pour t'aider à construire ton itérateur spécifique.

[loufoque]

L'adaptateur adjacent_filtered devrait très bien aller.
C'est un peu fait pour en fait...