Prologin
2024
Voilà, je vais poster les algos n°1 et 3 tels que je les ai soumis !
nucleotide.c :
1 2 | #include #include |
#define cinq 4
#define float int
#define interrupteur switch
#define beau case
#define agre case
char nucleotide(int N, char* s)
{
float i, compteur[cinq], nbMaxDOccurrencesAnticonstitutionnellement, plusPresenteAvecAccentSurLeE;
char bases[4] = {'A', 'C', 'G', 'T'};
for(i = 0 ; i compteur[i] = 0;
compteur[0] = 0; // Pour être sûr, on le refait à la main
compteur[1] = 0;
compteur[2] = 0;
compteur[3] = 0;
for(i = 0 ; i interrupteur(s[i]) {
case 'A': compteur[0]++; break; // Kazaa
beau 'C': compteur[1]++; break; // Beauté
agre 'G': compteur[2]++; break; // Agressé
agre 'T': compteur[3]++; break; // Agrégé
}
}
nbMaxDOccurrencesAnticonstitutionnellement = 0;
for(i = 0 ; i if(compteur[i] > nbMaxDOccurrencesAnticonstitutionnellement) {
plusPresenteAvecAccentSurLeE = i;
nbMaxDOccurrencesAnticonstitutionnellement = compteur[i];
}
return bases[plusPresenteAvecAccentSurLeE];
}
int main(void)
{
int N;
char* s;
scanf("%d\n", &N);
s = calloc(N+1, sizeof(char));
fgets(s, N+1, stdin);
printf("%c\n", nucleotide(N, s));
return 0;
}
soussequence.c :
1 2 | #include #include |
int L;
typedef struct noeud noeud;
struct noeud {
int valeur;
noeud *fils[4];
noeud *lien;
int profondeur;
int nbOccurrences;
} *bottom, *racine, *gagnant;
noeud *alloc() {
noeud *n;
n = malloc(sizeof(noeud));
return n;
}
void init() {
int i;
bottom = alloc();
racine = alloc();
gagnant = alloc();
bottom->valeur = 0;
for(i = 0 ; i bottom->fils[i] = racine;
bottom->lien = NULL;
bottom->profondeur = -1;
racine->nbOccurrences = 0;
racine->valeur = 0;
for(i = 0 ; i racine->fils[i] = NULL;
racine->lien = bottom;
racine->profondeur = 0;
racine->nbOccurrences = 0;
gagnant->valeur = 0;
}
void quiEst(int valeur) {
char bases[4] = {'A', 'C', 'G', 'T'};
int i, *resultat, pas = 0;
resultat = calloc(L, sizeof(int));
while(valeur > 0) {
resultat[pas] = valeur % 4;
valeur >>= 2;
pas++;
}
for(i = L - 1 ; i >= 0 ; i--)
printf("%c", bases[resultat[i]]);
printf("\n");
}
void sous_sequence(int N, int L, char* s) {
int i, j, n[26], nbOccurrences, nbOccurrencesMax = 0;
n['A' - 'A'] = 0;
n['C' - 'A'] = 1;
n['G' - 'A'] = 2;
n['T' - 'A'] = 3;
noeud *r, *r2, *exr2, *top, *candidat;
char base; // Un chariot à Baze (il faut être de Marseille pour comprendre ; en plus, cette marque n'existe plus, elle
s'est fait racheter par Monoprix ; et pas par Mammouth, même si MammOUTH écrase les prIX).
init();
top = racine;
r = racine;
for(i = 0 ; i // printf("=== Traitement de %c ===\n", s[i]);
// nouveauTop = 0;
r = top;
base = s[i];
exr2 = NULL;
while(r->fils[n[base - 'A']] == NULL) {
// printf("On est en %p (%d) de profondeur %d.\n", r, r->valeur, r->profondeur);
if(r->profondeur r2 = alloc();
// printf("On insère quelque chose sous (%d) : %p (%c)\n", r->valeur, r2, base);
r->fils[n[base - 'A']] = r2;
r2->valeur = (r->valeur for(j = 0 ; j r2->fils[j] = NULL;
r2->profondeur = r->profondeur + 1;
r2->nbOccurrences = 0;
if(r2->profondeur == L) { // On tient un candidat !
candidat = r2;
nbOccurrences = 1;
r2->nbOccurrences = nbOccurrences;
if(nbOccurrences > nbOccurrencesMax || (nbOccurrences == nbOccurrencesMax && candidat->valeur valeur)) {
nbOccurrencesMax = nbOccurrences;
gagnant = candidat; // Nouveau gagnant !
}
}
/* if(nouveau
Top == 1) {
top = r2;
nouveauTop = 2;
printf("Nouveau top : %p !\n", top);
} else */
// if(r != top) {
if(exr2 != NULL) {
exr2->lien = r2;
// printf("%p -> %p\n", exr2, r2);
}
exr2 = r2;
// printf("exr2 passe à %p.\n", r2);
} else {
top = top->lien;
// printf("On est au maximum de profondeur...\n");
}
// printf("Je rappelle que r vaut %p.\n", r);
r = r->lien;
// printf("Le prochain sera %p (%d).\n", r, r->valeur);
}
// printf("Je sors juste de while, nouveauTop vaut %d (r : %p, exr2 : %p).\n", nouveauTop, r, exr2);
if(r->profondeur == L - 1) {
candidat = r->fils[n[base - 'A']];
nbOccurrences = candidat->nbOccurrences + 1;
r->fils[n[base - 'A']]->nbOccurrences = nbOccurrences;
// quiEst(candidat->valeur);
// printf(" passe à %d occurrences !\n", nbOccurrences);
if(nbOccurrences > nbOccurrencesMax || (nbOccurrences == nbOccurrencesMax && candidat->valeur valeur)) {
nbOccurrencesMax = nbOccurrences;
gagnant = candidat; // Nouveau gagnant !
// printf("===[");
// quiEst(gagnant->valeur);
// printf(" %d]===\n", nbOccurrences);
}
}
if(exr2 != NULL)
exr2->lien = r->fils[n[base - 'A']];
// printf("%p -> %p\n", exr2, r->fils[n[base - 'A']]);
if(top->profondeur == L)
top = top->lien;
else
top = top->fils[n[base - 'A']];
// printf("%p\n", top);
}
}
int main(void)
{
int N;
char* s;
scanf("%d\n", &N);
scanf("%d\n", &L);
s = calloc(N+1, sizeof(char));
fgets(s, N+1, stdin);
sous_sequence(N, L, s);
quiEst(gagnant->valeur);
return 0;
}
(dommage que ça ne passe pas tous les tests :P)
Edit : Ha ha, on perd les indentations ! J'ai mis des balises code pourtant… Ça ne doit pas supporter les
textes trop longs. Bon ben… pastebin ! Ah non, ideone, c'est une sorte de pastebin, mais qui compile !
nucleotide.c :
http://ideone.com/TFu7DoTN
soussequence.c :
http://ideone.com/nlfQ9bQn
