Besoin d'aide pour écrire algorithme

Bonjour, je fais des études de biologie alors je dois dire que les algorithmes et moi ça fait 2!!! le problème c'est que je dois repassé cette matière en rattrage et il y a 2/3 exercices que je n'est pa compris quelqu'un pourrait il m'aider à les résoudre???

1.Ecrire un algorithme qui indiquerat si l'ADN retrouvé sur le site est éventuellement une sous chaine entière de l'ADN de la victime. On arretera la recherche des lors que l'on aurat identifié le fragment dans l'ADN de la victime
2.On retrouve dans le fragment trouvé sur le site un marqueur spécifique ATCTGTGTATCGTGT, le comparer ac celui des 2 suspect
suspect 1: ATCTCTGTATCGTGT
suspect2: ATCTAATATCGTGTA
il faut pour cela établir un algo qui permet de comparer les 2 séquences caractère par caractère en calculant une valeur score qui mesure la similitude de ces 2 sèquences.
pour une coordonace: ajouter au score global une note de "matching" fixée à 1
pour une non coordonance: soit insertion d'un espace vide sur une sèquence: ajouter au score une note de "gap" négative
soit une mutation: ajouter au score global une note de "mutation" négative
la note de gap et celle de mutation sont à faire saisir par l'utilisateur, dans le cas de non coordonance l'algo devrat choisir le score maximum

1. prpopsez un programme qui permet de reproduire la dynamique d'un petit réseau composé de 4 gènes te de 5 règles: A active B, A active C, B active D, C active D, D active A.
dès qu'un gène active un autre gène il est désactivé et peut etre reactivé dans la meme itération par un aitre gène.

Et enfin quelqun peut il me proposé un exempple de tableau ac 2 ligne et un nombre i de colonne pour comprendre comment s'utilise la variable tab [i]?
Configuration: Windows Vista Internet Explorer 7.0

7 réponses

  • Votes
  • Date
  • Date décroissante
  1. Modérateur
    Avec quel langage de programmation veux tu qu'on t'aide à faire tout ça ?
    1. j'avoue que je ne sait pa du tou la structure c'est:
      Début
      connaitre (nomb 1)
      connaitre (nomb 2)
      Si nomb 1> nomb 2
      alors écrire ('supérieur')
      .
      .
      Fin
      1. Modérateur
        Voici pour la première question un code en Pascal, je pense que le langage se comprend facilement et que tu pourras le transformer sans problème avec ta structure d'algorithme.

        Ici je regarde si ch2 est un fragment de ch1
        const NMAX=100; // taille maximale d'un brin d'ADN
        
        type baseAzotee=(A,T,C,G);
        
             ADN = record
                   a : array[1..NMAX] of baseAzotee;
                   n : integer; // taille du brin
                   end;
        
        function chercherAPartir(var ch1,ch2:ADN; k:integer):boolean;
        var i:integer;
        begin
             for i:=k to (k+ch2.n-1) do
             begin
                  if ch1.a[i]<>ch2.a[i]
                  then begin
                       result:=false;
                       exit;
                       end;
             end;
             result:=true;
        end;
        
        function estFragment(var ch1,ch2:ADN):boolean; // ch1.n > ch2.n
        var i:integer;
        begin
             for i:=1 to (ch1.n-ch2.n+1) do
             begin
                  if ch1.a[i]=ch2.a[i]
                  then begin
                       if chercherAPartir(ch1,ch2,i)
                       then begin
                            result:=true;
                            exit;
                            end;
                       end;
             end;
             result:=false;
        end;
        Pour les autres questions, propose ta solution (avec ta structure d'algorithme) on te dira ce qu'elles valent. De toute façon pour préparer un examen, le mieux c'est de faire des erreurs et les comprendre pour ne pas les refaire le jour J.
        1. merci beaucoup de m'aider. Comme tu me l'a conseillé j'ai éssayé de faire les autres algo:

          2.
          lexique
          chaine i: chaine de caractère /*chaine retrouvée*/
          chaine n : chaine de caractère /* chaine du suspect */
          score: réél
          score max: réél /* score obtenu si non concordance */

          début
          pour chaine i de à n faire
          si nucl [n] chaine i = nucl [n] chaine suspect
          résultat <--1
          sinon résultat <-- -1
          fin si

          score <-- résultat + résultat (1,n)
          si score = 15
          écrire ('15)
          sinon score <--score max
          fin si

          fin pour

          résituer (score)

          fin

          2.
          début
          pour i de 1 à n faire
          si A<-- B
          écrire 1
          sinon si A<-- C
          écrire 1
          sinon si B<--D
          écrire 1
          sinon si C<--D
          écrire 1
          sinon si D<--A
          écrire 1
          sinon écrire 0
          fin si
          fin si
          fin si
          fin si
          fin si

          fin

          je ne voudré pas abusé de ton temps mais j'en ai fait d'autre pour m'entrainer peut tu y jeté un coup d'oeil?

          écrire une fonction prenant en paramètre le mois et l'année de naissance d'une personne et donnant son age le 31 aout 2008

          donner_age (moi: entier, jour: entier): entier

          début
          connaitre (age)
          connaitre (jour)
          connaitre (moi)
          si jour actuel> jour
          age<-- age+1
          sinon si moi actuel> moi
          age<-- age + 1
          sinon age <-- age
          fin si
          fin si
          restituer (age)
          fin

          ecrire une fonction renvoyant un booléen exprimant si le millésime passé en paramètre est celui d'une année bissextile, on rapel qu'une année est bissextille si son anné est divisible par 4 ou 400 mais pa par 100

          connaitre_millèsime (année: entier, millésime: booléen): booléen
          Début

          connaitre (année)
          si année / 4 : entier
          millésime<-- 1
          sinon si année / 400: entier
          millésime <-- 1
          sinon si année/ 100: entier
          millésime<-- 0
          sinon millésime<-- 0
          fin si
          fin si
          fin si

          fin

          lors des essai d'un gran prix on chronomètre le tps mis par le pilote. Ecrire un algo qui demande a l'utilisateur chacun des temps puis affiche le tps total
          Ecrire un premier algo en supposant que l'utilisateur donne un temps nul pour arreter l'algo

          lexique

          temps tour: réél

          début

          connaitre (temps tour)
          pour tour de 1 à n faire
          tant que temps tour> 0 faire
          temps<-- temps tour
          temps total<temps tour + temps tous (2,n)
          fin tant que
          fin pour
          restituer (temps total)

          fin

          Ecrire une seconde version ou on demande à l'utilisateur au préalable le nombre de tour. L'algo doit s'arréter au bout du nombre de tour prévu
          lexique
          nb tour : entier
          temps tour: entier

          Début
          connaitre (nb tour)
          connaitre (temps tour)
          tant que nb tour>0 faire
          temps total<--temps tour + temps tour (2, n)
          fin tant que
          fin

          Ecrire une troisieme version en supposant que l'utilisateur donne un tps nul pour arreter l'algo mais cette fois l'algo affiche aussi le nb de tour effectué et le tps moyen au tour

          début

          connaitre (temps )
          pour tour de 1 à N faire
          tant que temps>0 faire
          nb tour<-- tour (1,n)
          temps moyen<-- temps total/ nb tour
          fin tant que
          fin pour
          restituer ( nb tour, temps moyen)

          fin
          1. merci beaucoup de m'aider. Comme tu me l'a conseillé j'ai éssayé de faire les autres algo:

            2.
            lexique
            chaine i: chaine de caractère /*chaine retrouvée*/
            chaine n : chaine de caractère /* chaine du suspect */
            score: réél
            score max: réél /* score obtenu si non concordance */

            début
            pour chaine i de à n faire
            si nucl [n] chaine i = nucl [n] chaine suspect
            résultat <--1
            sinon résultat <-- -1
            fin si

            score <-- résultat + résultat (1,n)
            si score = 15
            écrire ('15)
            sinon score <--score max
            fin si

            fin pour

            résituer (score)

            fin

            2.
            début
            pour i de 1 à n faire
            si A<-- B
            écrire 1
            sinon si A<-- C
            écrire 1
            sinon si B<--D
            écrire 1
            sinon si C<--D
            écrire 1
            sinon si D<--A
            écrire 1
            sinon écrire 0
            fin si
            fin si
            fin si
            fin si
            fin si

            fin

            je ne voudré pas abusé de ton temps mais j'en ai fait d'autre pour m'entrainer peut tu y jeté un coup d'oeil?

            écrire une fonction prenant en paramètre le mois et l'année de naissance d'une personne et donnant son age le 31 aout 2008

            donner_age (moi: entier, jour: entier): entier

            début
            connaitre (age)
            connaitre (jour)
            connaitre (moi)
            si jour actuel> jour
            age<-- age+1
            sinon si moi actuel> moi
            age<-- age + 1
            sinon age <-- age
            fin si
            fin si
            restituer (age)
            fin

            ecrire une fonction renvoyant un booléen exprimant si le millésime passé en paramètre est celui d'une année bissextile, on rapel qu'une année est bissextille si son anné est divisible par 4 ou 400 mais pa par 100

            connaitre_millèsime (année: entier, millésime: booléen): booléen
            Début

            connaitre (année)
            si année / 4 : entier
            millésime<-- 1
            sinon si année / 400: entier
            millésime <-- 1
            sinon si année/ 100: entier
            millésime<-- 0
            sinon millésime<-- 0
            fin si
            fin si
            fin si

            fin

            lors des essai d'un gran prix on chronomètre le tps mis par le pilote. Ecrire un algo qui demande a l'utilisateur chacun des temps puis affiche le tps total
            Ecrire un premier algo en supposant que l'utilisateur donne un temps nul pour arreter l'algo

            lexique

            temps tour: réél

            début

            connaitre (temps tour)
            pour tour de 1 à n faire
            tant que temps tour> 0 faire
            temps<-- temps tour
            temps total<temps tour + temps tous (2,n)
            fin tant que
            fin pour
            restituer (temps total)

            fin

            Ecrire une seconde version ou on demande à l'utilisateur au préalable le nombre de tour. L'algo doit s'arréter au bout du nombre de tour prévu
            lexique
            nb tour : entier
            temps tour: entier

            Début
            connaitre (nb tour)
            connaitre (temps tour)
            tant que nb tour>0 faire
            temps total<--temps tour + temps tour (2, n)
            fin tant que
            fin

            Ecrire une troisieme version en supposant que l'utilisateur donne un tps nul pour arreter l'algo mais cette fois l'algo affiche aussi le nb de tour effectué et le tps moyen au tour

            début

            connaitre (temps )
            pour tour de 1 à N faire
            tant que temps>0 faire
            nb tour<-- tour (1,n)
            temps moyen<-- temps total/ nb tour
            fin tant que
            fin pour
            restituer ( nb tour, temps moyen)

            fin
            1. Modérateur
              Tu dis que tu prends en paramètre mois et année, or ici tu prend jour et mois !
              De plus il faut absolument distinguer tes paramètres et tes variables
              En plus de ça tu as des erreurs de calculs
              donner_age (jour_actuel: entier, mois_actuel: entier, année_actuelle: entier): entier
              début
              
              connaitre (année_naissance)
              connaitre (mois_naissance)
              connaitre (jour_naissance)
              
              age: entier <-- année_actuelle - année_naissance
              
              si (mois_actuel < mois_naissance)
              ou (mois_actuel = mois_naissance et jour_actuel < jour)
              age <-- age -1
              fin si
              
              restituer (age)
              fin
              Pour les années bissextiles, les sinon_si sont incorrectes, en effet si une année est divisible par 100 elle n'est pas bissextile, or comme elle est divisible par 4, tu considère qu'elle l'ait !
              De plus dire si une division est en entier est absurde en informatique, si année est un nombre entier, il le restera même si la division en tombe pas juste !
              estBissextile (année: entier): booléen
              début
              
              resultat <-- faux // cas général par défaut
              
              si année mod 4 = 0 : resultat <-- vrai //cas particulier qui invalide le cas général
              si année mod 100 = 0 : resultat <-- faux // cas encore plus particulier
              si année mod 400 = 0 : resultat <-- vrai // idem
              
              restituer(resultat)
              
              fin
              Comme tu le vois tu commets un nombre importants d'erreurs à chaque fois !
              Je te laisse corriger les 3 derniers, en te demandant de te concentrer sur l'énoncé !
              Par exemple tu utilises le nombre de tour N, alors que dans 2 des 3 cas, tu ne le connais pas d'avance...
              1. j'ai donc essayé de reprendre

                1.
                lexique
                temps tour: réél
                temps total: réél

                début
                Pour tour de 1 à n faire
                tant que temps tour>0 faire
                temps tour <-- temps observé /* temps donné par l'utilisateur a chaque tour*/
                temps total<-- temps tour 1+ temps tour (2,n)
                fin tant que
                fin pour
                restituer (temps total)
                fin

                2.
                lexique
                nb tour: entier
                tps tour: entier
                tps total: entier

                début
                connaitre (nb tour)
                tant que nb tour>0 faire
                tps tour<--temps observé /*temps donné par l'utilisateur a chaque tour*/
                tps total<-- temps tour1+temps tour (2,n)
                fin tant que
                fin pour
                restituer (tenps total)
                fin

                3.
                lexique
                tps tour:entier
                nb tour: entier
                tps moyen: entier

                début
                pour tour de 1 à n faire
                tant que tps tour>0 faire
                nb tour<-- tour observé
                tps total<-- temps tour 1+ tps tour (2,n)
                tps moyen<-- temps total/ nb tour
                fin tant que
                fin pour
                restituer (nb tour)
                restituer(tps moyen)
                fin