Je cherche un code (en vba excel ou en C) qui permettrait d'effacer les éléments qui sont au moins en double d'un tableau, pour ne garder qu'un exemplaire de chaque élément.

Par exemple si y'a dans mon tableau :
yannick0011,
grosse_nouille,
grosse_nouille,
grosse_nouille,
yannick0011
toine3105

A la fin j'ai :
yannick0011,
grosse_nouille,
toine3105

De quels tableaux parles-tu? Ca ne pourrait pas etre plus vague...
Est-ce une feuille Excel, un array en C, un vector en c++, un fichier texte avec une entree par ligne, etc?

C'est un tableau de caractères tout simple genre
Dim tab() as String
dont la taille peut varier mais bon comme peu de monde utilise vba excel je me suis dit qu'en C j'aurai plus de réponses et qu'après je pourrais me débrouiller pour convertir en vba.

Et en C mon tableau serait déclaré comme
char tab[]
et remplit avec ce que j'ai dit plus haut.

Non, il ne serait certainement pas déclaré comme ça en C.

Si l'ordre des éléments ne t'importe pas. Le moyen le plus simple est de commencer par trier ton tableau (il y a surement des fonctions déjà faites pour ça) et ensuite à éliminer tout les éléments qui sont identique à celui qui le précède par exemple (tu peut recopier petit à petit les éléments que tu n'enlève as dans un nouveau tableau). Si l'ordre de tes éléments est important, alors tu peut passer par une table de hachage pour stocker les éléments que tu as déjà vu, mais c'est plus complexe et tu n'en as peut-être pas besoin.

ça ne me paraît pas très compliqué.

à supposer que tu veuilles garder les éléments dans l'ordre où ils sont :

tu pars de la première case.
-d'abord, si elle est vide, tu cherches la prochaine case qui n'est pas vide et tu échanges leurs contenus respectifs
-ensuite, tu parcours les cases du tableau et chaque fois que tu tombes sur un doublon, tu vides la case incriminée (tu mets NULL ou "" dedans ou je ne sais quoi en fonction du type de valeurs que contient ton tableau).

et tu fais ça pour chaque case de ton tableau.

en C ça doit ressembler à ça :

for (int i=0 ; i<INDEX_MAX ; i++)
{

if (tableau[i]=NULL)
{
while (int j=i+1 <= INDEX_MAX & tableau[j]=NULL)
{j++;};
if(j<=INDEX_MAX)
{tableau[i]=tableau[j];tableau[j]=NULL;}
}

while (j=i < INDEX_MAX)
{
j++
if (tableau[j]==tableau[i])
{tableau[j]=NULL;}
}
}

je ne connais pas le C donc je ne peux pas garantir que la syntaxe est correcte, et il est possible qu'il y ait des erreurs, mais enfin c'est l'idée

C'est pas idiot comme méthode. C'est du O(n²) contre (n*log(n)) pour ce que j'ai proposé, mais c'est relativement simple. Par contre, ça doit assez mal s'adapter au cas du VBS.

P.S. Et avec les tables de hachage, ont peut le faire en O(n) à peu près.

Finalement j'ai réussi à ma manière après il manque juste une fonction pour redéplacer les noms de manière à ce qu'ils soient à la suite les uns des autres (sans trou dans le tableau)

//*On compare chacun des éléments du tableau avec tous les autres éléments du tableau *//
For i = 0 To index_max
For j = 0 To index_max - 1
//*On ne compare pas l'élément du tableau avec lui même*//
If j = i - 1 Then GoTo Saut2
If tab(i) = tab(j + 1) And tab(i) <> "" Then tab(j + 1) = ""
Saut2:
Next j
Next i

mais :

-je ne comprends pas pourquoi tu utilises j+1 (même quand tu écris "if j=i-1" ça revient à écrire : "if j+1=i") alors que tu ne devrais pas le faire si tu initialisais j à 1 et pas à 0.

-si tu parcours le tableau avec i à partir de la case 0, et que chaque fois tu élimines les doublons, tu es sûr que toutes les cases précédemment pointées par i n'ont plus de doublon. Donc, plus besoin de les vérifier. Donc, tu peux commencer la vérification à (i+1) et écrire :

For j=i+1 To index_max

comme ça tu peux supprimer la vérification "if j=i-1"

Ouaip t'as surement raison je testerai mais la rapidité est pas primordial pour mon projet.