Bioinformatica, prof. Barbuti

Informatica

<nome, valore>

ES:

• [ x, 5 ] - [ y, 8 ]

Comandi

• Assegnazionenome ⟵ espressione

ES:

• x ⟵ 5 + 2 ;Cambio il valore di x in 7x ⟵ x + 1

• Variabili = nomi il cui valore può essere modificato
• Sequenza{ 1, 2 }

ES:

• x ⟵ x + yy ⟵ y - 3

• Condizionaleif condizionecomando 1elsecomando 2

ES:

• if (x > 0)x ⟵ x - 1;
• elsex ⟵ x + 1;

• if x > 0x ⟵ x - 1,else{ y ⟵ y + 1,x ⟵ x + y / 3x ⟵ x + 2 }

While (condizione) comando 1 -> si valuta la condizione, se è falsa lo salto rimanendo inattivo, se è vera si esegue il comando 1, quindi si ritorna e si segue di nuovo l’intero while

Massimo comune divisore tra due interi

Regola di Euclide MCD (n, n) = n

MCD (n, m) = MCD (n-m-m) con n>m

MCD (n, m) = MCD (m, m-n) con m>n

{_{n V1} , <m V₂ >}

while (n! = m)

if (n>m) n-n.m, else m-m.n;

{<n, MCD (V₁, V₂) > <m, MCD (V₁, V₂)>}

Funzione fattoriale

N: N->N

0! = 1

n.1 = n (n-1) (n-2) … 1 n∈N⁰

n! = n. (n-1)! è una funzione ricorsiva

> ES:

{<n,V₁>,<Fact,V₂>}

{Fact = 1

While (n>1) {Fact = Fact * n; n = n - 1; }

Inclusioni

#include <nomefile.h> Indica al preprocessore di sostituire le righe con il contenuto del file nomefile in un direttory di sistema.

#include "nomefile.h" Indica al preprocessore di sostituire del file con il contenuto del file nomefile da ricercare nella directory corrente.

ES: #include ... int x = 10; main () { } }

Recapitolando

• x = x + 2Assegnamento
• {x = x + 2;y = y + 1;}Sequenze
• If (x > 3) x = x + 1;Else x = x + 2;Condizionale

BUBBLE SORT

È parte dall'inizio e lo scorre fino alla fine. Confronta ogni elemento con il successivo e se è il caso, li scambia.

Esercizio

Ordinate i valori di un array in modo non decrescente (si dice così se ho degli elementi uguali) :

#include <stdio.h>

int i, j;

int Temp;

int a[10];

main ()

⇒ Legge i 10 valori come prima ⇐

for (i = 9; i > 0; i--) → ?

for (j = 0; j < = i - 1; j++)

if (a[j] > a[j+1])

{ Temp = a[j];

a[j] = a[j+1];

a[j+1] = Temp;

}

printf ("I valori ordinati sono :\n");

for (i = 0; i < 10; i++)

printf ("%d", a[i]);

printf ("/n");

getchar();

getchar();

Procedura per il fattoriale

void fact (int n)

{

    int f = 1;

    while (n >= 2)

    {

        f = f * n;

        n = n - 1;

    }

    printf ("%d", f);

}

int x;

scanf ("%d", &x);

fact(x);

Pila di frame

...dividiamo ciò che abbiamo fatto fino ad ora in due pile di frame

AMBIENTE

MEMORIA

y   l₁

x   l₂

← Indirizzi di memoria

... l₁ 6

... l₂ 5

← Valori

- Stato astratto - è diverso da quello concreto che è la memoria concreta del calcolatore

Occorre rappresentare nello stato astratto gli indirizzi di memoria.

*ris = *ris * 2;

n = n - 1;

void stampa(int n, int ris)

printf("il risultato di 2 alla %d e %d", n, ris);

int calc(int n)

int pot = 1;

while (n > 0)

{

pot = pot * 2;

n = n - 1;

}

return pot;

}

Main ()

{

int e;

int r;

r = leggi();

e = calc(r);

stampa (e, r);

}

Esercizio

Scrivere una funzione in C, con intestazione

int check (int a[], int dim)

che controlli che non ci siano, in a, 3 elementi contigui con lo stesso valore.

int check (int a[], int dim)

int i = 1;

int trovato = 0;

while (i < dim - 1 && !trovato)

• if ((a[i-1] == a[i+1]) && (a[i-1] == a[i-1]))
• trovato = 1;
• else
• i++;

return trovato;

Esercizio

Scrivere una procedura in C, con intestazione

void maxandpos (int a[], int dim, int *max, int *pos)

che restituisca nei parametri max e pos rispettivamente

il valore massimo e l'indice di esso nell'array.

Se il valore massimo compare più volte restituisca l'indice

della 1ᵃ occorrenza.

void maxandpos (int a[], int dim, int *max, int *pos)

int i, *max = 0; *pos = 0;

for (i = 0; i < dim; i++)

• if (a[i] > *max)
• *max = a[i];
• *pos = i;

Esercizio

Scrivere una funzione

void sumuni (char a [], int dim, int x, int * ind, int * nnu)

• int i
• int mnu=0;
• for (i = dim-1; i >= 0; i--)
• if (a[i]==x)
• { *ind=i;
• *nnum=*nnum+n;
• }
• }

int sum (int a[], int dim)

• somma=0
• for (i=0; i < dim-1; ++i)
• if a[i]< 50
• somma= somma +a[i];
• return somma;

int check (int a[], int dim)

• cont=0;
• if dim-1 == 18
• return trovato
• else
• while (i < dim- && ! trovato)
• sista_cont=0;
• sista_cont=1 &&
• { if (a[i-1]-a[i]==1)
• conta=conta +1
• if conta >= k)
• { trovato=1;
• }
• }
• i=i+ n;
• }
• if conta==0
• { return trovato;
• }