salut les amis,
j'ai un problème,
en fait, je génére aléatoirement une séquence des 0 et des 1.
j'obtiens une séquence de la forme 11010011001010110101010101010101011110110101010101
enfin, des choses comme ça.
après, je veux déterminer à partir de cette séquence une séquence de symbole définie comme suit:

si 0 , le symbole associé est 0
si 11, le symbole associé est 1
si 101 , le symbole associé est 2
si 1001, le symbole associé est 3
donc, par exemple, si je prends la séquence suivante des 0 et 1:    1101011101001010100110110
je dois obtenir          10210302001010.
il s'agit donc d'un traiement par morceau de la séquence des 0 et 1,
j'arrive pas à la faire.
merci pour vos aides.
salut

Bonjour,

C'est pas très compliqué ! Voilà un exemple de réalisation :

#include <stdio.h>
#include <string.h>

// ---------------
// Coder la chaîne
// ---------------
const char* Coder
(
    const char* pszEntree // E:chaîne à traiter
   ,char*       pszSortie // S:chaîne traitée
)                         // S:chaîne traitée
{
   const char* pcEntree = pszEntree;
   char*       pcSortie = pszSortie;
   while (*pcEntree)
   {
      if (*pcEntree == '0')
      {
         // --- Ici entrée = '0' --> '0' en sortie
         *pcSortie++ = '0';
         ++pcEntree; // on saute le '0'
         continue;   // on passe à l'entrée suivante
      }

      // --- Ici entrée = '1', tester ce qui suit
      if (*(pcEntree + 1) == '1')
      {
         // --- Ici entrée = '11' --> '1' en sortie
         *pcSortie++ = '1';
         pcEntree += 2; // on saute le '11'
         continue;      // on passe à l'entrée suivante
      }

      // --- Ici entrée = '10', tester ce qui suit
      if (*(pcEntree + 2) == '1')
      {
         // --- Ici entrée = '101' --> '2' en sortie
         *pcSortie++ = '2';
         pcEntree += 3; // on saute le '101'
         continue;      // on passe à l'entrée suivante
      }

      // --- Ici entrée = '100', tester ce qui suit
      if (*(pcEntree + 3) == '1')
      {
         // --- Ici entrée = '1001' --> '3' en sortie
         *pcSortie++ = '3';
         pcEntree += 4; // on saute le '1001'
         continue;      // on passe à l'entrée suivante
      }

      // --- Ici entrée = 1000, rien à faire
      ++pcEntree; // on passe à l'entrée suivante
   }
   *pcSortie = 0; // terminateur
   return pszSortie;
}

// -------------------
// Fonction principale
// -------------------
int main()
{
   const char* szChaine = "1101011101001010100110110";
   char szResultat[32];

   printf("%s --> %s\n",szChaine,Coder(szChaine,szResultat));
   return 0;
}

Ce qui donne :

1101011101001010100110110 --> 10210302001010

Jean-François

salut monsieur,
merci pour toute cette explication,
mais, monsieur, la suite des 0 et 1 n'est pas une chaine de caractère, elle est obtenue en générant aléatoirement une séquence des 0 et 1.
en fait, ceci se fait à l'aide des lignes de code suivantes


#define dim 100     //par exemple
int tab[dim];
 for(i=0;i<dim;i++)
tab[i]=rand()%2;

ainsi, je vais obtenir un tableau des entiers mais dont chaque case contient 0 ou 1.
mon problème c'est ce que je viens de poser.
comment traduire  cette séquence d'entiers (0 et 1)  en une autre séquence (0 et 1 et 2 et 3 ) en respectant l'aasociation suivante

0--------->0
1---------->11
2----------->101
3----------->1001.

je vous remercie monsieur une autre fois.
salut

Voilà avec des entiers en entrée et en sortie :

#include <stdio.h>
#include <string.h>

// ------------------------------
// Séquencer un tableau d'entiers
// (qui sont des booléens)
// ------------------------------
// {0}       --> 0
// {1,1}     --> 1
// {1,0,1}   --> 2
// {1,0,0,1} --> 3
// ------------------------------
int Sequencer
(
    const int* paiEntree // E:tableau d'entiers
   ,int        iLongueur // E:nombre d'entiers en entrée
   ,int*       paiSortie // S:tableau d'entiers
)                        // S:longueur de la sortie
{
   int iSortie = 0;
   for (int iEntree=0 ; iEntree<iLongueur ; ++iEntree)
   {
      if (paiEntree[iEntree] == 0)
      {
         // --- Ici entrée = 0 --> 0 en sortie
         paiSortie[iSortie++] = 0;
         continue; // on passe à l'entrée suivante
      }

      // --- Ici entrée = 1, tester ce qui suit
      if (paiEntree[iEntree + 1] == 1)
      {
         // --- Ici entrée = 11 --> 1 en sortie
         paiSortie[iSortie++] = 1;
         iEntree += 1; // on saute le 11
         continue;     // on passe à l'entrée suivante
      }

      // --- Ici entrée = 10, tester ce qui suit
      if (paiEntree[iEntree + 2] == 1)
      {
         // --- Ici entrée = 101 --> 2 en sortie
         paiSortie[iSortie++] = 2;
         iEntree += 2; // on saute le 101
         continue;     // on passe à l'entrée suivante
      }

      // --- Ici entrée = 100, tester ce qui suit
      if (paiEntree[iEntree + 3] == 1)
      {
         // --- Ici entrée = 1001 --> 3 en sortie
         paiSortie[iSortie++] = 3;
         iEntree += 3; // on saute le 1001
         continue;     // on passe à l'entrée suivante
      }

      // --- Ici entrée = 1000, rien à faire
      ++iEntree; // on passe à l'entrée suivante
   }
   return iSortie;
}

// -------------------
// Fonction principale
// -------------------
int main(void)
{
   const int aiEntree[] = {1,1,0,1,0,1,1,1,0,1,0,0,1,0,1,0,1,0,0,1,1,0,1,1,0};
   int aiSortie[32];

   int iLongueurEntree = sizeof(aiEntree) / sizeof(int);
   for (int i=0 ; i<iLongueurEntree ; ++i) printf("%d",aiEntree[i]);
   printf(" --> ");

   int iLongeurSortie = Sequencer(aiEntree,iLongueurEntree,aiSortie);
   for (i=0 ; i<iLongeurSortie ; ++i) printf("%d",aiSortie[i]);
   printf("\n");

   return 0;
}

Jean-François

merci monsieur,
mais je vous ai dit que la séquence est alétoire, elle n'est plus constante, on aurait pu donner la séquence suivante:
111001110101101101010101011101
ou celle ci
1111111111111111111111111111111
ou celle ci 001010101010101101100011001101111111111111110000000000001010111011001101110110
donc, la séquence des 0 et 1 est aléatoire mais on connait seulement sa taille (dimension du tableau contenant les 0 et 1).
je veux que votre programme associe à chaque séquence (aléatoirement donnée: on me connait pas d'avance) une suite des 0,1,2,3 appropriée.
j'espère que vous avez compris maintenant la problème.
désolé pour le dérangement.
merci beaucoup

Ca n'a rien à voir avec le séquençage à réaliser !

C'est à vous de renseigner le tableau d'entier dans la fonction main() avec ce que vous voulez traiter. Je n'y ai mis que les données de l'exemple cité. En ajoutant la génération aléatoire, la fonction principale devient :

int main(void)
{
   #define dim 100 // par exemple
   int tabEntree[dim],tabSortie[dim];
   for (int i=0 ; i<dim ; ++i) tabEntree[i] = rand() % 2;

   for (i=0 ; i<dim ; ++i) printf("%d",tabEntree[i]);
   printf(" --> ");

   int iLongeurSortie = Sequencer(tabEntree,dim,tabSortie);
   for (i=0 ; i<iLongeurSortie ; ++i) printf("%d",tabSortie[i]);
   printf("\n");

   return 0;
}

Jean-François

merci beaucoup monsieur.
je vous remercie indéfiniment.
une autre fois merci.
cordialement youssef