Aide sur les tableaux

bonjour a tous,
j'ai un probleme a résoudre et j'ai besoin de votre aide :slight_smile:

je vous explique j'aimerai transformer ce tableau booléen :

bool tab[10]={0,0,0,0,0,1,0,1,0,0};

en ce tableau booléen :

bool tab[10]={0,0,0,0,0,0,0,1,0,0};

en gros j'aimerai qui si mon tableau contient plusieurs valeur (true) alors mon tableau dois garder que le true qui est positionner au plus loin dans le tableau

j'espere que vous m'avez compris :slight_smile:

pouvez vous m'aider ?

Bonjour,

Il suffit de parcourir le tableau à partir de la fin et de mettre toutes les valeurs à 0 à partir du momemt ou on a trouvé un 1.

  bool trouve1=false;
  for (int i=sizeof tab-1; i>=0; i--)
  {
    if (trouve1)
    {
      tab[i]=0;     // on met à 0 tous le 1 après avoir trouvé le dernier
    }
    else
    {
      if (tab[i])
        trouve1=true;
    }
  }

et en utilisant true et false puisqu’on est avec des booléens, avec

tab[i]=false;

ce serait tout de suite plus sympathique :slight_smile:

Oui, bien sur.
J'ai failli faire la remarque que les valeurs d'un booleen ce n'était pas 0 et 1, mais false et true. Mais je me suis adapté à la syntaxe du programme donné.

et on peut remplacer

if (tab[i])
        trouve1=true;

par

trouve1=tab[i];

On est fainéant ou on ne l'est pas

Oups, j'avais dit des co***ries. J'efface mon message

si votre tableau est toujours plus petit que 16/32/64 valeurs, vous pourriez prendre un uint16_t (entier non signé sur 16 bits ou version sur 32 ou 64 bits) et utiliser des bits pour représenter vos valeurs de vérité, par exemple

uint16_t valeurs = 0b0000010100;

avec les 0 qui disent faux et les 1 qui disent vrai. dans ce cas avec une petite fonction sympa du compilateur __builtin_clz() et un masque, on peut mettre à zero tous les bits après le premier 1 simplement

uint16_t valeurs = 0b0000010100;

void setup() {
  Serial.begin(115200);
  byte premier1 = 15 - __builtin_clz(valeurs); // 255 si pas de 1, sinon de 0 à 15 pour la position
  Serial.print(F("avant: valeurs = 0b")); Serial.println(valeurs, BIN);
  if (premier1 != 0xFF) valeurs &= ((uint16_t) 1) << premier1;
  Serial.print(F("après: valeurs = 0b")); Serial.println(valeurs, BIN);
}

void loop() {}

le moniteur série (à 115200 bauds) affichera

[color=purple]
avant: valeurs = 0b10[color=red]1[/color]00
après: valeurs = 0b10[color=blue]0[/color]00
[/color]

ça permet d’économiser de la mémoire si besoin

pour lire les valeurs de vérité à l’index i vous pouvez utiliser bitRead();

Merci a tous mon probleme est résolu :slight_smile:

On doit même pouvoir solutionner ça avec des calculs de logarithmes en base 2. Mais ça serait plus simple si les bits étaient rangés dans l'ordre inverse et qu'il fallait conserver le 1 le plus a gauche.

Si on a

uint16_t x = 0b0001000110010010

La petite entière du log en base 2 donne la position du 1 a conserver. Il suffit de faire pow (2, partie_entiere) pour obtenir le résultat

int log2 = log(x)/log(2);
int y = pow(2, log2);

Devrait renvoyer 0b0001000000000000

couteux :slight_smile:

Oui mais stylé ;D

c'est vrai

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.