Discussion :

[FstDsi]

Salut,
Je suis débutante en c++.Je manipule un tableau qui est déjà rempli au préalable par des entiers.Je voulais développer une fonction qui me calcule le nombre d'occurrence de chaque élément,mais je ne sais pas pourquoi ça ne fonctionne pas.Cette fonction me retourne de faux résultats et j'arrive pas à voir la provenance du problème.Le code est le suivant:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int get_occurence(int *t,int N,int valeur)
{
	int nb_occurence=0;
 
	for(int s=0;s<N;s++)
	{
		if (t[s]==valeur)
		{
		nb_occurence=nb_occurence+1;
		}	
	}
	return(nb_occurence);
}

et pour l'appel de la fonction:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int *col ;
int main(int argc, char* argv[])
{
....
int supp[100];
for (int k=0;k<nbcol;k++)  //nbcol c'est la taille du tableau col déja rempli
{
	supp[k]=get_occurence(col,nbcol,col[k]);
}
return 0;
}

[Lucien63]

Cette fonction me retourne de faux résultats et j'arrive pas à voir la provenance du problème.

La fonction retourne bien le bon résultat. Le problème est ailleurs.

Peut-être voulez-tu appeler la fonction plutôt comme cela :

Code :

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

	supp[k]=get_occurence(col,nbcol,k);

(tout en considerant que le pointeur col pointe bien sur un tableau)

[Mac LAK]

Là, via "supp[k]=get_occurence(col,nbcol,col[k])", tu cherches à connaître, pour chaque élément du tableau "col", le nombre d'occurrences de chacun des nombres contenu dedans.

Donc, sur un tableau col valant { 1, 1, 2, 2, 3, 3, 4, 1 }, ton tableau "supp" vaudra { 3, 3, 2, 2, 2, 2, 1, 3, 0, ... }.

En effet, la valeur à l'indice I du tableau "supp" est le nombre d'occurrences du nombres de même indice dans le tableau "col".
Donc, supp[0] est le nombre d'occurrences de col[0] dans le tableau col, donc le nombre d'occurrences du chiffre "1".

Était-ce bien ce que tu cherchais à faire ?

[FstDsi]

Salut,

Merci pour vos réponses.En fait,ce que je veux faire avec la fonction get_occurence(col,nbcol,col[k]) est de connaitre, pour chaque élément du tableau "col", le nombre d'occurrences de chacun des nombres contenu dedans,mais sans redondance.Je m'explique:

pour un tableau "col" qui contient les valeurs suivantes { 1,1,2,2,2,2,3,3,4,1} mon tableau "supp" contiendra les valeurs suivantes {3,4,2,1}.

[Mac LAK]

En fait,ce que je veux faire avec la fonction get_occurence(col,nbcol,col[k]) est de connaitre, pour chaque élément du tableau "col", le nombre d'occurrences de chacun des nombres contenu dedans,mais sans redondance.Je m'explique:

pour un tableau "col" qui contient les valeurs suivantes { 1,1,2,2,2,2,3,3,4,1} mon tableau "supp" contiendra les valeurs suivantes {3,4,2,1}.

Alors ton algo est faux, même si ta fonction get_occurence est par contre juste...

Je t'explique : d'une part, un "int", c'est 32 bits en général, donc les valeurs peuvent monter jusqu'à deux milliards environ. Ton tableau "supp" n'est bien sûr pas assez grand, la mémoire de ton ordinateur non plus d'ailleurs...

De plus, ton tableau "supp" ne contient plus l'information "quel est le nombre compté ?" : comment savoir à quel nombre correspond le "2" contenu dans supp[2], dans ton exemple ? (N'oublie pas, en C/C++, les indices de tableau commencent à zéro...)
Car en effet, "col[2]", lui, contient "2"... Et ce n'est pas le nombre correspondant !


Donc, si tu veux savoir combien de fois chaque chiffre est contenu dans le tableau "col", pas trop le choix : il va falloir associer le chiffre et son cardinal dans le tableau "col", et autrement que via un indice étant donné le domaine de définition d'un int. En général, on utilise des structures pour ça, et dans ton cas tu vas simplement devoir chercher si tu as déjà compté un nombre donné avant de le faire, pour ne pas avoir de redondances.

Toutefois, tu peux aussi passer par la bande, en faisant une copie de ton tableau "col", en le triant, puis en comptant beaucoup plus facilement les occurrences... Reste à savoir ce qu'il te fallait faire : implémenter un algorithme particulier, ou simplement avoir le résultat...

[FstDsi]

Oui c'est vrai je me rends compte maintenant que je dois utiliser un tableau de structure (composée de deux entiers) pour que je puisse garder le contenu du nombre dont je cherche l'occurrence:

Code :

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

1
2
3
4
5
6
 
struct couple 
{
int ind_ligne;
int ind_colonne;
};

Je vais vous expliquer mon problème exactement.Ce que je suis en train de faire c'est de lire à partir d'un fichier composé de 0 et 1 et ce que j'essaie de faire c'est d'extraire les positions de 1(num_ligne,num_colonne) sachant que je sais d'avance le nombre de lignes et le nombre de colonnes dans ce fichier.
Le fichier aura donc cette forme:

1 0 0 1 0 0
0 1 1 1 1 0
1 0 0 0 0 0
....
J'ai stocké ces indices dans deux tableaux l'un pour les lignes et l'autre pour les colonnes

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
int main(int argc, char* argv[])
{
	ligne=new int[9999];// tableau pour stocker l'indice des lignes
	col=new int[9999];// tableau pour stocker l'indice des colonnes
 
 if(!(fichier = fopen("c:\\aa.data", "rb")))
     {
       printf("Ouverture de %s impossible.\n");
       return 1;
     }
int i=0;
int cptl=0;
int cptc=0;
 
while(!feof(fichier))
    {
	 fscanf ( fichier, "%s", &tmp);
     if(cptc>=nbcol)//nbcol et nbligne déjà extraits avant 
	{
     cptl++;
     cptc=0;
	}
	 if(tmp[0]=='1')
	{
	 ligne[i]=cptl;
	col[i]=cptc;
	i++;
	}
cptc++;	
}
 
for(int j=0;j<i-1;j++)
{
printf("%d | %d \n",ligne[j],col[j]);//affiche les indices de tous les 1 dans le fichier
 
}
return 0;
}

Ce que je veux faire après c'est trier les colonnes selon le nombre de 1 qu'elles contiennent c'est pour cela que je cherche le nombre d'occurrence des éléments de la table col.Pour l'exemple que je viens de mentionner on obtient les résultats suivants:
ligne={0,0,1,1,1,1,2}
col={0,3,1,2,3,4,0}
normalement le tableau supp qui sera une structure va me retourner:
supp=[0|2,1|1,2|1,3|2,4|1,5|0]

Je sais que c'est un peu compliqué mais je me retrouve confondu avec les indices. Apparemment je n'est pas choisi de bonnes structures dès le départ.Pourriez vous m'aider svp

[JolyLoic]

pour un tableau "col" qui contient les valeurs suivantes { 1,1,2,2,2,2,3,3,4,1} mon tableau "supp" contiendra les valeurs suivantes {3,4,2,1}.

J'ai du mal à comprendre la structure du résultat, sauf si tu as la garantie que ton tableau initial ne contient que des très petits nombres.

Le moyen le plus simple de faire ça dans le cas général est :

Code :

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

1
2
3
4
5
map<int, int> occurences;
for (int i = O, i<nbCol ; ++i)
{
  occurences[col[i]]++;
}

Et maintenant, la map contient pour chaque nombre le nombre de fois où il apparait.