Opérations bit à bit

**flo_k** · 10/10/2006, 11h44

Bonjour,
je ne savais pas ou mettre ca, j'ai un petit problème mathématique, voici une petite équation :

x = 1111 & (1000100011100110111001001110001 >> 8);
x = 1111 & (10001000111001101110010);
x = 10;

Ok, voila maintenant en connaissant x, je voudrais retrouver 8 que j'appelle y plus bas :

10 = 1111 & (1000100011100110111001001110001 >> y);

Quelles sont les étapes pour retrouver y = 8 ?

Merci de votre aide.

**jc-miranda** · 10/10/2006, 13h10

Deja, je ne comprends pas comment tu passes de :

Code :

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

1
2
 
10 = 1111 & (1000100011100110111001001110001 >> y);

a :

Code :

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

1
2
 
10 & 1111 = 10001000111001101110010 >> y;

sachant que :
considerons a=0, b=1, c=0,
a = b & c est vrai, mais a & c = b est faux.

Et qu'en plus tu as shifte la valeur 1000100011100110111001001110001 de 8 mais maintenu le shift dans l'equation.

Je ne comprends pas bien la logique de tout ca, je l'avoue. :-?

**flo_k** · 10/10/2006, 14h56

effectivement j'avais déja fait ces erreurs,
j'ai édité mon premier post,
reste toujours que je n'arrive pas a retrouver la valeur 8 pour mon y

**Neitsa** · 10/10/2006, 15h56

Bonjour,

il n'est pas possible de trouver la solution sans passer par la méthode tu "trial and error", car l'opération de shift n'est pas réversible (elle engendre une perte d'information).

Théoriquement, il y a trois réponses valables pour l'opération : y = 8 ou 25 ou 29. (la dernière réponse (29) est sujette à caution, si il y a injection de bits à zéro sur la gauche durant le décalage, cela fonctionne).

Code :

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

1
2
3
4
5
6
7
8
9
10
 
x = 1111 & (1000100011100110111001001110001 >> 25);
x = 1111 & (100010);
x = 10;
 
--------------------
 
x = 1111 & (1000100011100110111001001110001 >> 29);
x = 1111 & (10); // ok si injection de 0 sur la gauche lors du shift à droite
x = 10;

Pour retrouver au moins la première réponse il faut partir du nombre à décaler et à chaque décalage regarder si les 4 bits à droite valent '0010'. En gros il suffit juste de trouver le pattern '0010' (soit 2 en décimal) dans le nombre à décaler.

soit : x = z & (w >> y)

x := 0; // résultat
z := 15; // 1111b (constante)
w := 1148416625; // chiffre à décaler
y := -1; // compteur décalage

FAIRE
y := y + 1;
x := z & (w >> y);
TANTQUE x != 2

en C :

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
 
int main (void)
{
     int z = 15;
     int w = 1148416625;
     int y = -1;
     int x = 0;
 
	do{
		y ++;
		x = z & (w >> y);
	}while (x != 2);
 
	printf ("resultat : %i", y);
 
	return 0;
}

resultat : 8

J'espère que ca t'aidera un petit peu.

**flo_k** · 10/10/2006, 17h08

Envoyé par Neitsa

Pour retrouver au moins la première réponse il faut partir du nombre à décaler et à chaque décalage regarder si les 4 bits à droite valent '0010'. En gros il suffit juste de trouver le pattern '0010' (soit 2 en décimal) dans le nombre à décaler.

Ici tu prend 0010 car tu connais la valeur :
10001000111001101110010
qui est justement la valeur que l'on souhaite retrouver en partant de la :

10 = 1111 & (1000100011100110111001001110001 >> y);

C'est bien ca ?
en faite j'aimerai faire comme si je ne connais pas le décalage a l'origine.

Merci pour vos réponses

**ielbenna** · 11/10/2006, 11h32

Ici tu prend 0010 car tu connais la valeur :
10001000111001101110010
qui est justement la valeur que l'on souhaite retrouver en partant de la :

10 = 1111 & (1000100011100110111001001110001 >> y);

non c'est valable si on connais pas "y" car tu doit chercher la premiere occurence où on a 1111 & 0010 = 10
autrement dit on veux trouver ça:

************0010*****
& 0000000000001111
----------------------------
= 0000000000000010

"y" sera le nombre des (*) à droite de 0010