AN FI Metodologie1 Metodologie di progetto Metodologie top-down e bottom-up

AN FI Metodologie1 Metodologia top-down u Si parte dal problema e dalle proprieta note sul dominio dei dati u Si disgrega il problema in sottoproblemi u Si affronta ciascun sottoproblema (con la stessa metodologia) fino a raggiungere problemi risolubili con le mosse elementari

AN FI Metodologie1 Impostazione ricorsiva u Si esprime la soluzione di un caso particolare u Si tenta di disgregare il problema in modo da ricondurre la soluzione del caso generale al caso particolare

AN FI Metodologie1 Problema H(n) u Determinare il valore H(n) = 1 + 1/2 +1/ /n

AN FI Metodologie1 H(n): progetto u H(n): nat -> double IPOTESI: n >0 Riscrittura della relazione: H(n) = (1 + 1/2 + … + 1/(n-1)) + 1/n H(n) vale 1 per n = 1 H(n) vale 1/n + H(n-1) per n >1

AN FI Metodologie1 H(n): codifica double H( int n ){ return (n==1) ? 1: 1.0/n + H(n-1); }

AN FI Metodologie1 Problema: b k u Scrivere una funzione che restituisce il valore dellespressione che segue: b k con b reale, k intero, k>= 0

AN FI Metodologie1 b k : progetto u power(b,k) double x nat -> double IPOTESI: k >= 0 Riscrittura della relazione: b 0 = 1 b k = b * b k-1 per k > 0 power(b,k) -> 1 per k = 0 power(b,k) -> b*power(b,k-1) per k > 0

AN FI Metodologie1 b k : codifica double power(double b,int k){ return (k==0)? 1 : b*power(b,k-1); }

AN FI Metodologie1 Valore di un polinomio a coeff 1 u Scrivere una funzione che restituisce il valore dellespressione che segue: x n + x n x + x 0 con x reale, n intero, n>= 0

AN FI Metodologie1 Polinomio: progetto u Riscrittura della relazione: polin(x,n)= x n + x n x + x 0 = x n + (x n x + x 0 ) = x n + polin(x,n-1)

AN FI Metodologie1 Polinomio: codifica double pol( double x, int n ){ return (n==0)?1:power(x,n)+pol(x,n-1); }

AN FI Metodologie1 Polinomio: un altro ragionamento polin(x,n)= x n + x n x + x 0 = (... ( (x + 1 ) *x + 1 ) * x )* x + 1 v v = 1 v = v*x + 1n volte

AN FI Metodologie1 Polinomio: un altro ragionamento x 4 + x 3 + x 2 + x 1 + x 0 = (( ( x + 1 ) *x + 1 ) * x +1) *x +1 v = 1 v = v*x

AN FI Metodologie1 Polinomio: un altro ragionamento u so che al passo k=0, il valore corrente del polinomio vale 1 u sapendo che, al passo k, il valore corrente del polinomio vale v, al passo k+1 il valore corrente del polinomio vale v*x+1

AN FI Metodologie1 Polinomio double pol( double x, int n ){ return polin(x,n,1,0); } double polin (double x,int n,double v,int k){ return(k==n)?v:polin(x,n,v*x+1,k+1); }

AN FI Metodologie1 Fattoriale u N! = 1*1*2*3*…*N u so che al passo k=0, n! vale 1 u sapendo che, al passo k, n! vale v, al passo k+1 n! vale v*k

AN FI Metodologie1 Fattoriale int fact( int n ){ //so che al passo 0 n! vale 1 return factIter(n,1,0);} int factIter (int n,int v,int k){ //so che al passo k n! vale v //dunque al passo k+1 n! vale v*k return (k<n)?factIter(n,v*(k+1),k+1):v; }

AN FI Metodologie1 Contaminuscole u Definire una funzione ContaMinuscole che restituisca il numero di lettere minuscole del tipo prededfinito char int ContaMinuscole ()

AN FI Metodologie1 Contaminuscole: progetto u Partendo dal carattere a e procedendo con il carattere successivo, si incrementa un contatore, fino a raggiungere il carattere z u IPOTESI: –la funzione Succ(char c) restituisce il carattere ASCII successivo al carattere c

AN FI Metodologie1 Contaminuscole: riprogetto detto chIn il carattere di partenza e chEnd il carattere finale, –se chIn e uguale a chEnd il il numero dei caratteri e uguale al 1; –se chIn precede chEnd il numero dei caratteri e uguale al 1 piu il numero dei caratteri da Succ(chIn) a chEnd

AN FI Metodologie1 Contaminuscole: codifica int ContaMinuscole () { return contaChar(a,z); } La soluzione introduce un componente software (la funzione contaChar ) che risolve un problema piu generale di quello dato

AN FI Metodologie1 contaChar int contaChar(char chIn, char chEnd){ // chIn : carattere iniziale // chEnd: carattere finale return(chIn == chEnd) ? 1 : 1+c ontaChar (Succ(chIn),chEnd); }

AN FI Metodologie1 La funzione succ sui caratteri char Succ(char ch){ int succRep = ord(ch)+1;ord return (succRep<=255)?((char)succRep):\0; }

AN FI Metodologie1 Le funzioni ord e chr int ord(char ch){ return (int)ch;} char chr(int rapCh){ return ((rapCh>=0)&&(rapCh<=255))? (char)rapCh:\0;}

AN FI Metodologie1 Scorciatoie int contaChar(char chIn, char chEnd){ // chIn : carattere iniziale // chEnd: carattere finale return( chIn==chEnd ) ? 1 : 1+c ontaChar ((int)chIn+1,chEnd); }

AN FI Metodologie1 Un altro ragionamento contaChar puo ricevere come informazione di ingresso: –un carattere generico ch compreso tra chIn e chEnd ; –il valore nc del numero di caratteri che va dal carattere di inizio a ch contaChar(char ch,int nc,char chEnd) u In tal caso:

AN FI Metodologie1 Un ragionamento iterativo Se ch coincide con chEnd, allora il numero dei caratteri compresi tra chIn e chEnd vale nc Se ch precede chEnd, allora il numero dei caratteri compresi tra chIn e chEnd puo essere denotato dallespressione: contaChar(Succ(ch),nc+1,chEnd)

AN FI Metodologie1 contaCharTl int contaCharTl(char ch, int nc, char chEnd){ // ch : carattere corrente // nc: numero dei caratteri dallinizio a ch // chEnd: carattere finale return(ch==chEnd)? nc : c ontaCharTl (Succ(ch),nc+1,chEnd); }

AN FI Metodologie1 ContaMinuscole int ContaMinuscole () { contaCharTl return contaCharTl (a,1,z); }

AN FI Metodologie1 Una strada molto breve u Avendo realizzato una funzione di trasformazione da caratteri a interi, la soluzione del problema e: ord(z)-ord(a)+1;

AN FI Metodologie1 Numero cifre u Determinare il numero di cifre decimali che compaiono in una stringa data

AN FI Metodologie1 Numero cifre: progetto int numCifre( String s ) u sapendo che nella sottostringa da 0 a k di s vi sono n digit, nella sottostringa da 0 a k+1: – vi sono n+1 digit se il carattere di posizione k+1 e un digit –vi sono n digit se il carattere di posizione k+1 non e un digit

AN FI Metodologie1 Numero cifre: codifica int numCifre( String s ){ return numCifre1( s,0,0 ); } int numCifre1(String s,int n,int k){ return (k==s.length()) ? n : ((isDigit(s.charAt(k))) ? numCifre1( s,n+1,k+1 ): numCifre1( s,n,k+1 ) ); }