Discussion :

[FryHandiz]

Bonjour,

Je reviens pour une question assez stupide mais... Étant donné que je suis débutante, je galère un peu !
Alors, je vais vous expliquer ce que je souhaiterais faire.

J'ai une suite de lettres, une lettre est "codée" par deux bits. Donc je me retrouve avec 4 lettres dans chaque octet.
Donc j'ai mon octet 0 (ATCG), mon octet 1 (CTTA) et mon octet 2 (AATT)
ATCG CTTA AATT
Je souhaite obtenir ma suite de lettre mais inversée.
TTAA ATTC GCTA

Premier souci :
Vu que je suis une quiche, pour le moment, j'ai juste réussi à inverser mes octets et obtenir ça :
AATT CTTA ATCG
Mais ça ne marche que pour des multiples de 4.
Par exemple avec ça :
ATCGCTTAAAT
J'obtiens ça :
AATACTTAATC
Mon G disparait et me laisse place à un A.

Voici ma boucle for :

Code :

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

1
2
3
4
5
6
size_t longueur_tab = (longueur/4 + (longueur%4 !=0)), temp = 0;
    for (size_t i = 0 ; i < (longueur_tab/2) ; i++){
    	temp = tab[i];
        tab[i] = tab[longueur_tab - i -1];
        tab[longueur_tab - i - 1] = temp;
	}

longueur : est la taille de ma séquence de A,T,C,G

Donc je suppose qu'en fait, ça va me prendre mes lettres par groupe de 4 comme ça :
ATC GCTT AAAT et pas comme ça ATCG CTTA AAT
Que puis-je faire du coup...?


Deuxième souci :
Comment obtenir : TAA ATTC GCTA
Si je ne dis pas de sottise, je crois que je dois manipuler les bits en utilisant <<
Mais je ne vois pas trop comment faire ça, du moins, la logique utilisée.
Mais ça, on n'y est pas encore
Si jamais vous avez des liens vers ce genre de choses qui semblent assez rudimentaires, je prends.

Et merci d'avance pour votre aide !

[Médinoc]

Le plus sûr, c'est d'isoler chaque composant avec les opérateurs bitwise, puis les remettre dans l'ordre inverse:

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
unsigned char inverseParDeux(unsigned char entree)
{
	unsigned char duo0 = (entree >> 0) & 0x03;
	unsigned char duo1 = (entree >> 2) & 0x03;
	unsigned char duo2 = (entree >> 4) & 0x03;
	unsigned char duo3 = (entree >> 6) & 0x03;
 
	unsigned char sortie = (duo0 << 6) | (duo1 << 4) | (duo2 << 2) | (duo3 << 0);
	return sortie;
}

[FryHandiz]

Me frappez pas mais j'ai quelques questions
Enfin, pour commencer déjà une. Que fait & 0x03 ? '

[FryHandiz]

Et je viens de me rendre compte que ce que j'ai fait ne marche pas si mes lettres ne sont pas un multiple de 4... TT

[Médinoc]

& c'est l'opérateur binaire ET bitwise, et 0x03 ça veut dire que seuls les deux bits de poids faible sont à 1. Donc, ça met tous les autres bits à zéro.

[FryHandiz]

Mmmh d'accord. Bon, finalement j'ai édité mon premier poste car je bloque un peu déjà dans ma première étape >.<

[Bousk]

Hello,

pour inverser les bits d'un octet, parcours-les du dernier au premier
à vue de nez, ceci devrait marcher

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
#include <climits>
#define GET_BIT(o,x) ((o) & (1<<(x)))
#define INNER_CLEAR_BIT(o,x) (o & ~(1<<x))
#define INNER_SET_BIT(o,x) (o | (1<<x))
#define SET_BIT(o,x,b) o = (b) ? INNER_SET_BIT(o,x) : INNER_CLEAR_BIT(o,x)
 
unsigned char reverse(unsigned char c)
{
	char r = 0;
	for ( unsigned int i = 0; i < CHAR_BIT; ++i )
	{
		SET_BIT(r, i, GET_BIT(c, CHAR_BIT - i - 1));
	}
	return r;
}

Et si tu veux remplacer l'unsigned char par n'importe quel autre type, suffit d'adapter avec un sizeof

[FryHandiz]

Merci beaucoup Bousk. Mais le problème c'est que je ne comprends pas trop ce que tu as fait. Je préfère quelque chose de moins optimisé et de plus facile à comprendre pour moi >.<'

[Bousk]

Il n'y a absolument rien d'optimisé ou de mystérieux dans mon code. C'est justement un simple algorithme qu'il suffit de lire/dérouler pour le comprendre.

[FryHandiz]

En fait je ne comprends pas ça xD :
#define GET_BIT(o,x) ((o) & (1<<(x)))
#define INNER_CLEAR_BIT(o,x) (o & ~(1<<x))
#define INNER_SET_BIT(o,x) (o | (1<<x))
#define SET_BIT(o,x,b) o = (b) ? INNER_SET_BIT(o,x) : INNER_CLEAR_BIT(o,x)

Pas tapeeeeeer !

[RPGamer]

Si les opérations bit à bit ne sont toujours pas clair, je t'invites à relire mon post dans ton précédent sujet : http://www.developpez.net/forums/d15...n/#post8566949

Pour ton tri, je pense que tu peux passer tes nucléotides dans un tableau temporaire, les inverser puis recréer ton tableau compressé.

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
std::vector<char> sequence{{...}};
 
std::vector<char> tmp(sequence.size() * 4);
 
for (size_t i = 0; i < sequence.size(); i++)
{
    tmp[i] = sequence[i] & 0x03;
    tmp[i + 1] = sequence[i] & 0x0C;
    tmp[i + 2] = sequence[i] & 0x30;
    tmp[i + 3] = sequence[i] & 0xC0;
}
 
std::reverse(tmp.begin(), tmp.end());
 
for (size_t i = 0; i < sequence.size(); i++)
{
    sequence[i] = (tmp[i + 3] << 6) | (tmp[i + 2] << 4) | (tmp[i + 1] << 2) | tmp[i];
}

[Bousk]

#define GET_BIT(o,x) ((o) & (1<<(x)))
#define INNER_CLEAR_BIT(o,x) (o & ~(1<<x))
#define INNER_SET_BIT(o,x) (o | (1<<x))
#define SET_BIT(o,x,b) o = (b) ? INNER_SET_BIT(o,x) : INNER_CLEAR_BIT(o,x)

Ce sont juste des macros pour manipuler des bits, leurs noms sont on ne peut plus explicites btw.
Si tu ne parviens pas à les décrypter, est-ce que ton problème ne serait pas juste que tu espères manipuler des bits sans savoir ce que c'est ni les opérations élémentaires qui y sont liées ?
A ce moment-là je t'invite à (re)lire ton cours, parce que si un tel exercice vous a été demandé, c'est que vous avez les billes pour parvenir à sa résolution.

[FryHandiz]

Justement, le souci c'est qu'on n'a eu qu'un bref cours de C++ avec quelques petites bases et que notre enseignant souhaite qu'on réalise un API de mapping. Enfin, c'est, pour quelqu'un comme moi qui n'a jamais fait d'informatique une tâche quasi impossible x) Mais j'avais au moins envie de faire cette petite étape. Pour les bits, on nous a juste dit qu'un octet était constitué de 8bits. Voilàààà
Je vais regarder ça RPGamer, merci !

[foetus]

Pourtant ce sont des maths

entrée b = 00000001 (notation binaire), b = 0x01 (notation hexadécimale) ou 1 (notation décimale)

b << 3 -> décalage à gauche de 3 bits, b << 3 = 00001000, b = 0x08 ou 8

avec la nouvelle valeur de b:
b >> 3 -> décalage à droite de 3 bits, b >> 3 = 00000001, b = 0x01 ou 1


Et il y aussi les tables AND (opérateur &) et OR (opérateur |)
0 AND 0 = 0
0 AND 1 = 0
1 AND 0 = 0
1 AND 1 = 1


0 OR 0 = 0
0 OR 1 = 1
1 OR 0 = 1
1 OR 1 = 1


Exemple:
a = 58 = 0x3A ou 00111010
b = 111 = 0x6F ou 01101111

a & b = 00111010 & 01101111 = 00101010 = 0x2A ou 42
a | b = 00111010 | 01101111 = 01111111 = 0x7F ou 127