Vous êtes sur la page 1sur 2

void permute(int *p, int ind fils1<ind_fils2 void construction(int

*q) { int temp=*p; *p=*q; if(ind_fils1==-1 && tab1[], int tab3[], int
*q=temp; } ind_fils2==-1) tab4[]) { int i; for(i=N-
{ printf("tab[%d]=%d n'a 1;i>=0;i--)
int somme(char *nombre) { pas de fils\n",ind_pere, { tab3[tab1[i]]--;
int som; int chiffre tab[ind_pere]); } else tab4[tab3[tab1[i]]]=tab1[i]
=(int)*nombre-'0'; //cas de if(ind_fils2==-1) ; } }
base if(*nombre=='\0') { printf("tab[%d]=%d a un
{ som=0; } //cas général seul fils : tab[%d]= void tri_denombrement(int
else { som = chiffre + %d\n",ind_pere, tab1[], int tab4[]) { int
somme(nombre+1); } return tab[ind_pere],ind_fils1, tab2[M],tab3[M];
som; tab[ind_fils1]); } else denombrement(tab1,tab2);
{ printf("tab[%d]=%d a un distribution(tab2,tab3);
int est_croissant(char* deux fils : tab[%d]=%d et construction(tab1,tab3,tab4
nombre) { int croissant, tab[%d]=%d\n",ind_pere, ); }
chiffre, tab[ind_pere],ind_fils1,
chiffre_suivant; // cas de tab[ind_fils1], ind_fils2, int est_seq_adn_it(char
base // la récursivité tab[ind_fils2]); } seq_adn[]) { int result=1,
atteint le dernier chiffre i=0; while (result &&
if(*(nombre+1)=='\0') void fonction (int *tab, seq_adn[i]!= '\0')
{ croissant=1; } else int ind_pere) { int { if(seq_adn[i]!='A' &&
{ chiffre=(int)*nombre; ind_fils1, ind_fils2; seq_adn[i]!='C' &&
chiffre_suivant=(int)*(nomb affiche_fils(tab, seq_adn[i]!='G' &&
re+1); //le chiffre courant ind_pere); printf("\n"); seq_adn[i]!='T') result=0;
est plus petit que le indice_fils(tab,ind_pere, i++; } return result; }
suivant &ind_fils1, &ind_fils2);
if(chiffre_suivant<chiffre) if(ind_fils1 !=-1) int est_seq_adn_rec(char
{ croissant=0; } else //cas fonction(tab, ind_fils1); seq_adn[]) { int result;
général if(ind_fils2 !=-1) if(seq_adn[0]=='\0')
{ croissant=est_croissant(n fonction(tab, ind_fils2); } result=1; else
ombre+1); } } return if(seq_adn[0]!='A' &&
croissant; seq_adn[0]!='C' &&
seq_adn[0]!='G' &&
int indice_pere(int* tab, seq_adn[0]!='T') result=0;
int ind_fils) { int else
ind_pere; if(ind_fils==0) result=est_seq_adn_rec(seq_
ind_pere=-1; else adn+1); return result; }
if(ind_fils%2)// indice est
impair ind_pere=ind_fils/2; void affiche_sequence(char
else ind_pere=ind_fils/2-1; Tri seq_adn[]) { int i;
return ind_pere; } échange printf("("); if(seq_adn[0]!
void tri_selection ='\0') {
void affiche_pere(int *tab, (int*tab) { int i,j, printf("%c",seq_adn[0]);
int ind_fils) { int ind_min; for(i=0;i<N-1;i++) i=1; while(seq_adn[i]!
ind_pere=indice_pere(tab,in { ='\0') { printf(",");
d_fils); if(ind_pere == -1) ind_min=i; for(j=i;j<N;j++) printf("%c",seq_adn[i]); i+
printf("tab[%d] = %d n'a { if(tab[j]<tab[ind_min]) +; } } printf(")\n"); }
pas de pere\n", ind_fils, ind_min=j; } echange(tab+i,
tab[ind_fils]); else tab+ind_min); } }
void
printf("tab[%d] = %d a
cree_complementaire(char
comme pere : tab[%d]= %d",
void affiche_tableau(int seq_adn[], char
ind_fils,
tab[ ]) { int i; seq_adn_comp[TAILLE_MAX]) {
tab[ind_fils],ind_pere,tab[
printf("[ "); int i=0; while (seq_adn[i]!
ind_pere]);
for(i=0;i<N;i++) printf("%d ='\0') {
",tab[i]); printf("]\n"); } if(seq_adn[i]=='A')
void indice_fils(int* tab,
seq_adn_comp[i]='T';
int ind_pere, int*
void denombrement(int if(seq_adn[i]=='T')
ind_fils1, int* ind_fils2)
tab1[], int tab2[]) { int seq_adn_comp[i]='A';
{ int n=2*ind_pere+1;
i; for(i=0;i<M;i++) if(seq_adn[i]=='G')
if(n<TAILLE)
tab2[i]=0; for(i=0;i<N;i++) seq_adn_comp[i]='C';
{ *ind_fils1=n; } else
tab2[tab1[i]]++; } if(seq_adn[i]=='C')
{ *ind_fils1=-1; }
seq_adn_comp[i]='G'; i++; }
if(n+1<TAILLE)
void distribution(int seq_adn_comp[i]='\0';
{ *ind_fils2=n+1; } else
{ *ind_fils2=-1; } tab2[], int tab3[]) { int
i; tab3[0]=tab2[0];
void affiche_fils(int *tab, for(i=1;i<M;i++)
int ind_pere) { int tab3[i]=tab3[i-
ind_fils1, ind_fils2; 1]+tab2[i]; }
indice_fils(tab, ind_pere,
&ind_fils1, &ind_fils2);//
int compare(char printf("Entrez
seq_adn_1[], char l'ordonnee du
seq_adn_2[]) { int result;
if((seq_adn_1[0]=='\0')&&(s vecteur :\n");
eq_adn_2[0]=='\0')) scanf("%f",&v->y); }
{ result =1; } else if
(seq_adn_1[0] !=
seq_adn_2[0]) { result = 0; int sont_colineaires
} else { result = (v_plan u, v_plan v) {
compare(seq_adn_1+1,seq_adn if(u.x*v.y-u.y*v.x==0)
_2+1); } return result;
return 0; else return
int est_complementaire( 1; }
char seq_adn_1[], char
seq_adn_2[]) { int result;
char
int main (void)
seq_adn_comp[TAILLE_MAX]; { v_plan u, v; int
cree_complementaire(seq_adn col;
_1, seq_adn_comp); result = printf("Coordonnees du
compare(seq_adn_comp,
seq_adn_2); return
premier vecteur ?\n");
result; } initialise_coordonnees
(&u);
char* recherche_codon(char affiche_vecteur(u);
seq_adn [], char codon[4])
{ char* find ; if
printf("Coordonnees du
(seq_adn[0]=='\0' || deuxieme
seq_adn[1]=='\0' || vecteur ?\n");
seq_adn[2]=='\0') initialise_coordonnees
find=NULL; else if
(seq_adn[0]==codon[0] &&
(&v);
seq_adn[1]==codon[1] && affiche_vecteur(v);
seq_adn[2]==codon[2]) col=sont_colineaires(u
find=seq_adn; else find = ,v); if(!col)
recherche_codon(seq_adn+1,c
odon); return find; } printf("Les vecteurs
intnb_occrence_coon(char sont
seq_adn[], char codon[4]) { colineaires !\n");
int nb_occ; char* else printf("les
debut_codon=recherche_codon
(seq_adn,codon); vecteurs ne sont pas
if(debut_codon==NULL) colneaires !\n");
{ nb_occ=0; } else return 0; }
{ nb_occ=1+nb_occurence_cod
on(debut_codon+3, codon); }
return nb_occ; }

typedef struct { float


x; float y;}v_plan;

void affiche_vecteur
(v_plan v)
{ printf("(%f,
%f)\n",v.x,v.y); }

void
initialise_coordonnees
(v_plan *v)
{ printf("Entrez
l'abscisse du
vecteur :\n");
scanf("%f",&v->x);