calcul de 0 et 1 dans un tableau [Résolu]

[M77ATTAR]

Bonjour,
dans un tableau qui contient seulement des '0' et des '1', je veux calculer la succession des deux éléments. Exemple:
Si le tableau de départ est : 0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0
Le tableau de résultat doit être: 5 3 4 2 2
C'est-à-dire: 5 zéro, suivit de 3 un, suivit de 4 zéros, etc.…
Le résultat que j'ai obtenu sur la console est: 5 3 4 2 Ce qui veut dire que les deux derniers zéros ne sont pas comptés !
Ma question est: comment faire pour avoir le bon résultat ?
Le code utilisé est le suivant:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdlib.h>
#include <stdio.h> 
 
void main(){
	int k,indice=0,couleur=0,noire=0,blanc=0;
	int t[16]={0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0};
	int *resultat; resultat=(int *)malloc(20*sizeof(int*));
// calcule de noire et blanc
  for(k=0;k<16;k++){
	  if(t[k]==couleur)
	  {
		  noire++;resultat[indice]=blanc;indice++;blanc=0;
	  }else{
		  blanc++;resultat[indice]=noire;indice++;noire=0; 
	       } 
 } 
 
// affichage de resultat
 for(k=0;k<16;k++){
	 if(resultat[k]==0) continue; else 
		 printf("%d\t",resultat[k]);
 } 
system("pause");
}

cordialement

[leternel]

c'est bien complexe comme réalisation.

que pense-tu de ceci:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h> 
 
int main() {
	const int max = 16;
 
	int input[max]={0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0};
 
	enum {initial=-1, zero, one}int current_kind = initial;
 
	int count = 0;
	for(int i = 0; i<max; ++i) {
		if (current_kind!=input[i]) {
			/* if(i!=0) marche aussi */
			if (count!=0) printf("%d ", count);
			current_kind = input[i];
			count = 1;
		} else {
			count++;
		}
	}
	printf("%d\n", count);
	return 0;
}

[M77ATTAR]

merci bien leternel, votre code m'a aidé bien, je veux savoir pourquoi vous avez declarer l'enumération "enem" alors que vous n'utilisé que "initial" ?

[Captain'Flam]

Juste pour s'amuser un peu, voici une version plus "compacte" :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int run_length ( int * resultat , int * t , int size )
    {
    int i,r,n,cur ;
    for ( i = r = 0 , n = -1 , cur = t[0] ; i < size ; cur = t[i] , n = 0 )
        {
        while ((i < size) && (cur == t[i++] )) n++ ;
        resultat[r++] = n+1 ;
        }
    return r ;
    }
 
void main ()
    {
    int n,i,t [16] = { 0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0 } ;
    int resulat [16] ;
    n = run_length( resulat,t,16 ) ;
    for ( i = 0 ; i < n ; ++i ) printf(" %d",resulat[i] ) ;
    }

qui affiche bien 5 3 4 2 2
Remarques :
- ne fonctionne que pour t contenant au moins 1 élément
- suppose que resultat est assez grand (il suffit qu'il soit aussi grand que t)
- si tous les bits de t sont inversés, le résultat est le même...
- cet algo ressemble au RLE.

[M77ATTAR]

merci bien à tous ! pas mal de solutions !!!

[leternel]

Envoyé par M77ATTAR

merci bien leternel, votre code m'a aidé bien, je veux savoir pourquoi vous avez declarer l'enumération "enem" alors que vous n'utilisé que "initial" ?

Pour rien, j'ai eu l'idée de l'utiliser, et en fait je n'en ai pas besoin, c'est un artefact de copié collé.

Mieux nettoyée, ma version ca donnerait donc ceci

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h> 
 
int main() {
	const int max = 16;
 
	int input[max]={0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0};
 
	int current_kind = -1;
 	int count = 0;
	for(int i = 0; i<max; ++i) {
		if (current_kind!=input[i]) {
			/* if(i!=0) marche aussi */
			if (count!=0) printf("%d ", count);
			current_kind = input[i];
			count = 1;
		} else {
			count++;
		}
	}
	printf("%d\n", count);
	return 0;
}