Universit`a di Camerino - Corso di Laurea in Informatica ...

Università di Camerino - Corso di Laurea in Informatica Programmazione + Laboratorio Esercizi delle Prove Scritte Parziali e Totali con Soluzione Docente: Luca Tesei Esercizi aggiornati a Dicembre 2012

1

Indice 1 Sintassi: Automi, Grammatiche, Espressioni Regolari

3

2 Funzioni Ricorsive, Sistemi di Transizioni

24

3 Semantica Operazionale

40

4 Programmazione Procedurale e su Sequenze

53

5 Classi, Oggetti, Metodi

62

2

1

Sintassi: Automi, Grammatiche, Espressioni Regolari

Esercizio 1.1. Si consideri il linguaggio L = {x d y | x ∈ {c, ab}∗ , y ∈ {b, d}∗ } Svolgere i seguenti punti: • disegnare un automa che accetti tutte e sole le stringhe di L • scrivere una grammatica regolare equivalente all’automa disegnato

SOLUZIONE

Esercizio 1.2. Si consideri il seguente automa: 3

b

1

a

3

c

5

c

0

a

a

{b ,c }

2

{b ,c }

4

• Si scriva il linguaggio accettato dall’automa mediante espressioni su insiemi • Si scrivano tutti i cammini etichettati dell’automa per la stringa aaa

SOLUZIONE Il linguaggio accettato può essere scritto come segue: L = {an (bc)m | n, m > 0} ∪ {an x | n > 0, x ∈ {b, c}∗ } I cammini etichettati per la stringa aaa sono i seguenti: a a a 0 −→ 0 −→ 0 −→ 0 a a a 0 −→ 0 −→ 0 −→ 1 a a a 0 −→ 0 −→ 0 −→ 2

Esercizio 1.3. Dato il seguente automa: {a, b}

a 0

c

a d

1

2

3

d • scrivere il linguaggio accettato tramite espressioni su insiemi • disegnare l’automa deterministico equivalente risultante dall’applicazione dell’algoritmo di costruzione dei sottoinsiemi.

SOLUZIONE

4

Esercizio 1.4. Si scriva il linguaggio accettato dal seguente automa utilizzando espressioni su insiemi:

5

a

{b, c} d

2

0 b

a

3

4

c

b

d 1

SOLUZIONE Il linguaggio si può scrivere nel modo seguente: L=

{an | n ≥ 0} ∪ {an b (cb)m d x | n, m ≥ 0, x ∈ {b, c}∗ } ∪ {an b (cb)m c d a x | n, m ≥ 0, x ∈ {b, c}∗ }

Esercizio 1.5. Si scriva un automa che accetta il seguente linguaggio: L = {x an c y | x ∈ {a, b}∗ , n > 0, y ∈ {b, c}+ } Si scriva poi una grammatica regolare equivalente all’automa proposto (si usi l’algoritmo di trasformazione visto a lezione).

SOLUZIONE Una possibile soluzione è la seguente:

a {a, b}

{b, c} 0

a

1

b

c

2

3 c

La grammatica regolare equivalente, utilizzando l’algoritmo di trasformazione, è la seguente:

→ → → →

a < 0 >| b < 0 >| a < 1 > a < 1 >| c < 2 > b < 3 >| b | c < 3 >| c b < 3 >| b | c < 3 >| c

6

Esercizio 1.6. Sia Σ = {a, b, c}. Si disegni un automa deterministico che accetti tutte e sole le stringhe su Σ che hanno come sottosequenza la stringa ab. Esempi di stringhe da accettare: bccaccaaababb, ccaccbaa, abaa, cababbb. Esempi di stringhe da non accettare: bbaaacca, aacc, bbbaa, .

SOLUZIONE Dapprima disegnamo l’automa non deterministico:

a

0

1

b 





2

Dopodiché lo trasformiamo in deterministico con la costruzione dei sottoinsiemi: Stato A = {0} B = {0, 1} C = {0, 1, 2}

a {0, 1} {0, 1} {0, 1, 2}

b {0} {0, 1, 2} {0, 1, 2}

c {0} {0, 1} {0, 1, 2}

L’automa deterministico risultante è il seguente:

A

a

{b , c}

Esercizio 1.7. Si scriva il linguaggio sioni su insiemi: S A B C D

B {a ,c }

b

C 

generato dalla seguente grammatica utilizzando espres→ → → → →

aS | bS | cAaB cAa | c C|D Cb | a cD |

SOLUZIONE Il linguaggio si può scrivere nel modo seguente: L = {x cn c an a bm | n > 0, m ≥ 0, x ∈ {a, b}∗ } ∪ {x cn c an cm | n > 0, m ≥ 0, x ∈ {a, b}∗ }

7

Esercizio 1.8. Sia L = {an bm ck d`+2 | k, ` ≥ 0, n > 0, m = n + k + 1} ∪ {x y | x ∈ {a, b}∗ , y ∈ {a, b}} : • si scriva una grammatica che generi tutte e sole le stringhe del linguaggio L • si disegni, usando la grammatica data, l’albero di derivazione per la stringa aabbbbbccdd

SOLUZIONE

8

Esercizio 1.9. Si scriva una grammatica che generi il seguente linguaggio: L = {an b cm d bk | m = n + k + 2, n > 0, k ≥ 0} ∪ {an b cm | n > 0, m ≥ 0}

SOLUZIONE Il linguaggio può essere scritto equivalentemente come segue: L = {an b cn cc ck d bk | n > 0, k ≥ 0} ∪ {an b cm | n > 0, m ≥ 0} Avendo esplicitato le ricorsioni centrali di cui abbiamo bisogno passiamo a scrivere la grammatica: S → A|B A → CccD C → aCc | abc D → cDb | d B → aB | aE E → Ec | b

Esercizio 1.10. Dato il seguente automa:

c

{a, c} 0

a

c

1

3 b

b 4

2

{c, d}

d

1. Scrivere il linguaggio accettato tramite espressioni su insiemi 2. Scrivere tutti i cammini etichettati per la stringa acccbd 3. Scrivere il linguaggio accettato dallo stesso automa, ma senza che lo stato 3 sia di accettazione. Sarebbe possibile, in questo caso, scrivere un automa equivalente con soli 3 stati? Se s`ı, disegnarlo; se no, dare una giustificazione della risposta.

SOLUZIONE Il linguaggio accettato dall’automa può essere scritto come segue: L = {x a cn | x ∈ {a, c}∗ , n > 0} ∪ {x a cn b d y | x ∈ {a, c}∗ , n > 0, y ∈ {c, d}∗ } ∪ {x b d y | x ∈ {a, c}∗ , y ∈ {c, d}∗ } 9

Si osserva tuttavia che la seconda componente dell’unione è completamente inclusa nella terza. Quindi il linguaggio può essere equivalentemente scritto come: L = {x a cn | x ∈ {a, c}∗ , n > 0} ∪ {x b d y | x ∈ {a, c}∗ , y ∈ {c, d}∗ } Nell’automa ci sono 2 cammini per la stringa acccbd: a

c

c

c

b

d

0 −→ 0 −→ 0 −→ 0 −→ 0 −→ 2 −→ 4 a c c c b d 0 −→ 1 −→ 3 −→ 3 −→ 3 −→ 2 −→ 4 Se lo stato 3 non è di accettazione allora la porzione di stringa a cn non porta pi` u a una stringa accettata senza che si continui con una b. Questo significa che la stessa porzione di stringa (a cn ) può essere costruita dall’automa nello stato 0 tramite il ciclo {a, c} per poi continuare con una b nello stato 2. Il linguaggio accettato diventa quindi solo: L = {x b d y | x ∈ {a, c}∗ , y ∈ {c, d}∗ } Per lo stesso motivo gli stati 1 e 3 diventano inutili e il linguaggio può essere accettato da un automa con soli tre stati:

{a, c} 0

b 4

2

{c, d}

d

Esercizio 1.11. Si consideri la seguente grammatica: S A B C

→ → → →

aAbB | aCba aAb | abb Bc | bb aCba |

• scrivere il linguaggio L(S) generato dalla grammatica tramite espressioni su insiemi • scrivere una espressione regolare che denoti L(B).

SOLUZIONE

10

Esercizio 1.12. Scrivere una grammatica libera dal contesto che generi il seguente linguaggio: L = {pn s q m r sk | n > 0, k ≥ 0, m = n + k}

SOLUZIONE Riscriviamo in maniera equivalente il linguaggio come: L = {pn s q n q k r sk | n > 0, k ≥ 0} Una grammatica che genera il linguaggio è la seguente: S → AB A → pAq | psq B → qBs | r 11

Esercizio 1.13. Si consideri la seguente grammatica: B → 0 | 1 | B • B | B ⊕ B | (B) • determinare, giustificando la risposta, se la stringa 0 • 1 ⊕ 0 • (1 ⊕ 1) appartiene a L(B) • dimostrare che la grammatica data è ambigua • fissando una precedenza maggiore dell’operatore • rispetto all’operatore ⊕ e sapendo che entrambi gli operatori associano a destra, scrivere una grammatica non ambigua per L(B).

SOLUZIONE

12

13

Esercizio 1.14. Si consideri la seguente grammatica: S A B C D E

→ → → → → →

AbB | Cd aAb | bB | aE bC | D Dc | a cE | d

1. Scrivere il linguaggio generato tramite espressioni su insiemi 2. Dimostrare che la grammatica è ambigua 3. Quali sono le produzioni della grammatica che non sono regolari? Sarebbe possibile esprimere L(C) con una grammatica regolare? Se s`ı, fornirla; se no, dare una giustificazione alla risposta.

SOLUZIONE Il linguaggio generato dalla grammatica è il seguente: L = {an bn b bm a ck d | n, m, k ≥ 0} ∪ {bn a cm d | n, m ≥ 0} La grammatica è ambigua per tutte le stringhe del sottolinguaggio L = {bn a cm d | n > 0, m ≥ 0}. Prendendo ad esempio la pi` u corta, bad, possiamo trovare i due seguenti alberi di derivazione diversi:

S A

S

b

B a

C E

b

d C

ε d

D a

Le seguenti produzioni sono sicuramente non regolari: S → AbB, A → aAb, C → D. Inoltre, le produzioni S → Cd, D → Dc presentano il simbolo non terminale a sinistra invece che a destra: possono essere considerate produzioni di una grammatica regolare sinistra. Il linguaggio L(C) = {bn a cm | n, m ≥ 0} è sicuramente un linguaggio regolare. Una possibile grammatica regolare che lo genera è la seguente: S → bS | aA A → cA |

14

Esercizio 1.15. Sia A = {b, c}. Si consideri il seguente linguaggio: L = {a d x an | x ∈ A∗ , n > 0} Si scriva una grammatica regolare che generi il linguaggio L.

SOLUZIONE Scriviamo dapprima un automa per il linguaggio:

a

0

d

1

A

2 a

4 A

a

3

a

Usiamo quindi l’algoritmo per la costruzione di una grammatica regolare a partire da un automa. Otteniamo la seguente grammatica regolare per il linguaggio dato:

→ → → → →

a d a < 3 >| a | b < 4 >| c < 4 > a < 3 >| a b < 4 >| c < 4 >| a < 3 >| a

Esercizio 1.16. Si consideri il seguente automa: a b a 0

3

5

d

{a, d}

2

c c

b

c 4

a

6

b

7

1

• Si scriva il linguaggio accettato tramite espressioni su insiemi. • Si scriva una espressione regolare e una grammatica regolare per il linguaggio che si ottiene considerando solo gli stati 2, 3 e 5 e lo stato 2 come iniziale.

15

SOLUZIONE

Esercizio 1.17. Si scriva una grammatica libera dal contesto che generi tutte e sole le stringhe del seguente linguaggio: L = {b an b ck a bn+k cm | n, m > 0, k ≥ 0} 16

SOLUZIONE Il linguaggio può essere equivalentemente scritto come segue: z }| { n ck{za bk bn} cm | n, m > 0, k ≥ 0} L = {b a b | dove sono evidenziate le due ricorsioni centrali una dentro l’altra. Una possibile grammatica è la seguente: S → bAB A → aAb | abCb C → cCb | a B → cB | c

Esercizio 1.18. Scrivere un automa deterministico che accetti tutte e sole le stringhe del seguente linguaggio: L = {an bm ck | n, k ≥ 0, m > 0} ∪ {an bk dm | k, m > 0, n ≥ 0} Scrivere, inoltre, il linguaggio di cui sopra come espressione regolare (si usino le regole di precedenza e associatività viste a lezione per gli operatori delle espressioni regolari).

SOLUZIONE Un automa possibile è il seguente:

c

2

b

a

c b 0

1 d d 3

Un’espressione regolare che denota il linguaggio è la seguente: a∗ b+ c∗ | a∗ b+ d+ Un’espressione equivalente è la seguente: a∗ b+ (c∗ | d+ )

17

Esercizio 1.19. Si considerino i seguenti linguaggi: L1 = {an bm cn dm | n, m > 0} L2 = {an bm ck | k > m, n = m + 1, m > 0, k > 0} L3 = {an bm ck dh | k = m + 2, h > n > 0, m > 0} Solo uno dei tre è esprimibile con una grammatica libera dal contesto. Si dica quale e si scriva per esso una grammatica che lo generi.

SOLUZIONE

Esercizio 1.20. Si disegni un automa che accetta il seguente linguaggio: L = (({a} · ({b} ∪ {c}))∗ · {bc}) · {cd}∗ Si scriva poi una espressione regolare che denota il linguaggio L dato.

SOLUZIONE 18

Esercizio 1.21. Si consideri la seguente grammatica: S → aAbB | abB A → aAbb | B → Bc | b 1. Scrivere il linguaggio generato tramite espressioni su insiemi 2. Dimostrare che la grammatica è ambigua

SOLUZIONE Il linguaggio è il seguente: L = {an b2n ck | n > 0, k ≥ 0} ∪ {abb ck | k ≥ 0} In realtà è possibile esprimere l’unione in un unico insieme dato che il secondo insieme è incluso nel primo (quando n = 1): L = {an b2n ck | n > 0, k ≥ 0} 19

Questa osservazione ci porta a scoprire che la grammatica è ambigua. Infatti per fare le stringhe del secondo insieme ci sono due modi: uno è utilizzare la prima produzione di S, facendo diventare A la stringa vuota con l’apposita produzione, e l’altro è utilizzare la seconda produzione di S. Basta quindi prendere una stringa qualsiasi del secondo insieme, ad esempio quella pi` u corta abb, per trovare due alberi di derivazione diversi:

S

S

a A

b B

ε

b

a

b

B b

Esercizio 1.22. Si consideri un linguaggio di espressioni i cui operandi sono simboli di {0, 1} e i cui operatori binari, − e ×, devono rispettare le seguenti regole: • − ha precedenza maggiore di × • − e × associano a destra Si indichi, inserendo le parentesi, qual’è l’ordine corretto di applicazione degli operatori nella espressione 0 × 1 × 1 − 0 − 1 × 0 − 1.

SOLUZIONE Per rispondere in maniera precisa conviene costruire una grammatica non ambigua per il linguaggio di espressioni dato, avendo cura di incorporare nella grammatica stessa le regole di precedenza e di associatività date. La grammatica è la seguente: A → B×A|B B → C −B |C C → 0 | 1 | (A) A questo punto basta costruire l’unico albero di derivazione per l’espressione data:

A B X A C

B X A

0

C 1

B C _ B 1

X

A

B _ C B C _ B

0

20

C 0

C

1

1

Dalla struttura dell’albero si ricava l’ordine preciso delle operazioni, indicato con le parentesi quadre nell’espressione seguente: [0 × [1 × [ [1 − [0 − 1] ] × [0 − 1] ] ] ]

Esercizio 1.23. Si consideri la seguente grammatica: S A B C

→ → → →

pAqr | sBp Ap | s sBp | r | rC qC |

• Si scriva il linguaggio generato dalla grammatica mediante espressioni su insiemi • Si disegnino gli alberi di derivazione delle stringhe: psppqr e ssrqpp • Si dimostri che la grammatica è ambigua

SOLUZIONE Il linguaggio generato si può scrivere come segue: L = {p s pn q r | n ≥ 0} ∪ {sn r q m pn | n > 0, m ≥ 0} Gli alberi di derivazione delle due stringhe richieste sono i seguenti:

p

psppqr

ssrqpp

S

S

A

q

A

p

A

p

r

s

B

p

s

B

p

r

C

s

q

C 

Per dimostrare che la grammatica è ambigua è sufficiente che almeno una stringa del linguaggio abbia almeno due alberi di derivazione diversi associati. Nel nostro caso, ad esempio, la stringa srp ha i due seguenti alberi associati:

S s

B

S s

p

r

B

p

r

C 

21

Esercizio 1.24. Dato il seguente automa:

a

b

0

1

2

a

b

c

1. Scrivere il linguaggio accettato tramite espressioni su insiemi 2. Disegnare l’automa deterministico equivalente ottenuto applicando la costruzione dei sottoinsiemi

SOLUZIONE Il linguaggio accettato è il seguente: L = {an bm ck | n, m > 0, k ≥ 0} La tabella risultante dall’algoritmo di costruzione dei sottoinsiemi è la seguente: A = {0} B = {0, 1} C = {1, 2} D = {2}

a {0, 1} {0, 1}

b {1, 2} {1, 2}

c

{2} {2}

Mark √ √ √ √

Quindi l’automa deterministico equivalente è il seguente:

b

a a

b

B

A

S B D C A E

→ → → → → →

c C

Esercizio 1.25. Si consideri la seguente grammatica: aBc | aACd aBc | aD | aE cD | bD | c abC | ba aAbb | cE | bc 22

c

D

• Si scriva il linguaggio generato dalla grammatica mediante espressioni su insiemi. • Si dimostri che la grammatica è ambigua.

SOLUZIONE

23

2

Funzioni Ricorsive, Sistemi di Transizioni

Esercizio 2.1. Si scriva una funzione ricorsiva delete: List(IN ) × IN −→ List(IN ) tale che delete(`, n) restituisca una lista di numeri naturali uguale a `, ma in cui tutte le occorrenze del numero n sono state cancellate. Ad esempio: delete(1 :: 2 :: 2 :: 3 :: nil , 2) = 1 :: 3 :: nil delete(1 :: 1 :: nil , 1) = nil delete(0 :: 2 :: 5 :: nil , 3) = 0 :: 2 :: 5 :: nil

SOLUZIONE Una soluzione è la seguente:   nil delete(`0 , n) delete(`, n) =  0 n :: delete(`0 , n) 24

se ` = nil se ` = n0 :: `0 e n0 = n se ` = n0 :: `0 e n0 6= n

Esercizio 2.2. Si consideri la funzione fibo : N → N definita   1 1 fibo(n) =  fibo(n − 1) + fibo(n − 2)

come segue: se se se

n=0 n=1 n>1

• determinare il valore di fibo(7) • scrivere una funzione ricorsiva apply fibo : List(N) → List(N) che, presa una lista ` di numeri naturali, applica ad ogni elemento n di ` la funzione fibo e restituisce la lista dei risultati (ad esempio apply fibo(1 :: 4 :: nil ) = fibo(1) :: fibo(4) :: nil = 1 :: 5 :: nil )

SOLUZIONE

25

Esercizio 2.3. Si consideri una grammatica G le cui produzioni sono S → bcS | acS | bc | ac 1. Scrivere il linguaggio generato dalla grammatica tramite espressioni su insiemi 2. Scrivere un sistema di transizioni nello stile big–step che trasformi una stringa α ∈ L(S) in una stringa in cui tutte le occorrenze di ac sono state rimpiazzate con una d. Ad esempio: acbcbcac →∗ dbcbcd. 3. Eseguire una derivazione del sistema costruito a partire dalla configurazione bcbcac indicando nella giustificazione di ogni passo di derivazione anche la sostituzione ϑ delle variabili della regola usata.

SOLUZIONE

26

Il linguaggio generato dalla gramamtica è: L(S) = {x | x ∈ {bc, ac}+ } Il sistema, Sd , ha le configurazioni Γd = {α | α ∈ L(S)} ∪ {β | β ∈ {bc, d}+ }. Le configurazioni terminali sono {β | β ∈ {bc, d}+ }. La relazione di transizione, →d , è definita dalle seguenti regole: (r1) ac →d d (r2) bc →d bc α ∈ L(S),

α →d β (r3)

ac α →d d β α ∈ L(S),

α →d β (r4)

bc α →d bc β La derivazione per la stringa bcbcac è la seguente:

bcbcac →d

{ (r4), ϑ = {bcac/α, bcd/β} bcac ∈ {bc, ac}+ , (d1): bcac →d bcd } bcbcd

dove la sottoderivazione d1 è la seguente: (d1) : bcac →d

{ (r4), ϑ = {ac/α, d/β} ac ∈ {bc, ac}+ , (r1): ac →d d } bcd

Esercizio 2.4. Si consideri una grammatica G le cui produzioni sono S → aaSb | aab Si consideri poi un sistema di transizioni S2 = hΓ2 , T2 , →2 i dove Γ2 = {α |∈ L(G)} ∪ {n | n ∈ IN }, T2 = {n | n ∈ IN } e →2 è definita dalle seguenti regole: 27

(r1) aab →2 2 α ∈ L(G)

α = aaβb

β →2 n (r2)

α →2 2 + n 1. Eseguire una derivazione del sistema S2 a partire dalla configurazione aaaaaabbb specificando tutte le sostituzioni effettuate sulle variabili delle regole condizionali usate 2. Esplicitare cosa fa il sistema S2 : ∀α ∈ L(G).α →∗2 ?.

SOLUZIONE Eseguiamo la derivazione:

aaaaaabbb →2

{ (r2), ϑ = {aaaaaabbb/α, aaaabb/β, 4/n} (d1): aaaabb →2 4, 2+4=6 } 6

La sottoderivazione (d1) è la seguente:

aaaabb →2

{ (r2), ϑ = {aaaabb/α, aab/β, 2/n} (d2): aab →2 2, 2+2=4 } 4

La sottoderivazione (d2) è la seguente:

aab →2

{ (r1), ϑ = {} } 2

Il sistema conta il numero di a presenti nella stringa α di partenza. In formule: ∀α ∈ L(G).α = a2k bk ∧ α →∗2 n ⇒ n = 2k

28

Esercizio 2.5. Si scriva una funzione ricorsiva even count(`) che, presa una lista ` di numeri naturali, restituisce quanti numeri all’interno della lista sono pari. Ad esempio: even count([2,1,1,3,4,0,2])= 4 dato che nella lista ci sono i numeri pari 2 (due volte), 4 e 0.

SOLUZIONE   0 even count(`0 ) + 1 even count(`) =  even count(`0 )

se ` = nil se ` = n :: `0 e n % 2 = 0 se ` = n :: `0 e n % 2 6= 0

Esercizio 2.6. Si scriva una funzione ricorsiva sum odd(`) che, presa una lista ` di numeri naturali, restituisca la somma di tutti i numeri dispari presenti all’interno della lista. Ad esempio: sum odd([2,1,1,3,4,0,2])= 1 + 1 + 3 = 5.

SOLUZIONE  se  0 0 se sum odd(` ) sum odd(`) =  n + sum odd(`0 ) se

` = nil ` = n: : `0 e n mod 2 = 0 ` = n: : `0 e n mod 2 6= 0

Esercizio 2.7. Si scriva una funzione ricorsiva append: List(N) × List(N) → List(N) che prese due liste `1 e `2 restituisce la concatenazione delle due. Ad esempio: append(1 :: 2 :: nil, nil) = 1 :: 2 :: nil e append(1 :: 2 :: nil, 3 :: 4 :: nil) = 1 :: 2 :: 3 :: 4 :: nil. Suggerimento: si usi la ricorsione solo su una delle due liste.

SOLUZIONE

29

Esercizio 2.8. Si consideri la seguente grammatica: S → aS | bcS | Si scriva un sistema di transizioni oppure una funzione ricorsiva che, presa α ∈ L(S), calcoli il numero di occorrenze della sottostringa bc in α.

SOLUZIONE

30

Esercizio 2.9. Si consideri la seguente grammatica: S → abS | abaB B → Bb | b Si scriva un sistema di transizioni che prenda stringhe generate da S e sostituisca tutte le occorrenze di ab con cd. Ad esempio la stringa ababababbbbb deve essere trasformata in cdcdcdcdbbbb.

SOLUZIONE Notiamo innanzitutto che una stringa x ∈ L(S) inizia sempre una sequenza (ab)n con n almeno uguale a 2. Dopo tale sequenza ci sono un certo numero, anche zero, di b. Basandoci sulla sintassi e su tale osservazione sono sufficienti due regole e non quattro come suggerirebbe l’approccio guidato dalla sintassi. Infatti basta fare una regola ricorsiva che trasforma una sequenza iniziale ab in cd quando quello che segue inizia con una sequenza (ab)n con n almeno 2. Quando invece ci troviamo di fronte a una stringa che inizia esattamente con la sequenza 31

abab (n = 2) allora (caso base) trasformiamo questa in cdcd e copiamo tutte le eventuali b che restano. x ∈ L(S)

x→y (r1)

ab x → cd y x ∈ b∗ (r2) abab x → cdcd x

Esercizio 2.10. Si consideri la grammatica S → aS | cS | a | c. Si scriva un sistema di transizioni small-step S` = hΓ` , T` , →` i che contenga almeno le configurazioni {hα, STARTi | α ∈ L(S)} ∪ {hb, STOPi | b ∈ {true, false}} e che determini se in una data stringa α ∈ L(S) il numero di a sia esattamente uguale al numero di c. Ad esempio, haaca, STARTi →∗` hfalse, STOPi mentre hcaacac, STARTi →∗` htrue, STOPi.

SOLUZIONE

32

Esercizio 2.11. Si consideri la seguente grammatica: S → aSb | C C → cC | c • Scrivere il linguaggio generato

33

• Definire un sistema di transizioni che, presa una stringa α ∈ L(S), restituisca una stringa in cui tutti i caratteri sono stati raddoppiati. Ad esempio, la stringa aaaccbbb deve diventare aaaaaaccccbbbbbb. Un altro esempio: la stringa c deve diventare cc. • Eseguire una derivazione per la stringa accb con il sistema definito, indicando la sostituzione effettuata nella giustificazione di ogni passo

SOLUZIONE Il linguaggio è L(S) = {an ck bn | n ≥ 0, k > 0}. Il sistema →d ha le seguenti regole: (r1) c →d cc α ∈ c+ ,

α →d β (r2)

c α →d cc β α ∈ L(S),

α →d β (r3)

a α b →d aa β bb La derivazione per la stringa accb è la seguente:

accb →d

{ (r3), ϑ = {cc/α, cccc/β} cc ∈ L(S), (d1): cc →d cccc } aaccccbb

dove la sottoderivazione d1 è la seguente: (d1) : cc →d

{ (r2), ϑ = {c/α, cc/β} c ∈ {c}+ , (r1): c →d cc } cccc

Esercizio 2.12. Si consideri la grammatica S → aS | bS | cS | a | b | c • si definisca un sistema di transizioni big-step S3 = hΓ3 , T3 , →3 i che, per una data stringa α ∈ L(S), calcoli il numero n = 3 · αb + 2 · αc dove αb è il numero di simboli b in α e αc è il numero di simboli c in α 34

• si mostri la derivazione del sistema che si è definito sulla stringa abbc (si mostrino le sottoderivazioni a parte), cioè si faccia vedere come un esecutore del sistema calcola il numero associato alla stringa abbc.

SOLUZIONE

35

36

Esercizio 2.13. Sia Σ = {0, 1, 2, . . . , 9}. 1. Scrivere un sistema di transizioni nello stile small–step che contenga almeno le seguenti configurazioni: {hα, STARTi | α ∈ Σ+ } ∪ {hn, STOPi | n ∈ IN } tale che se hα, STARTi →∗ hn, STOPi allora n è la somma delle cifre pari che appaiono in α. Ad esempio h894720256, STARTi →∗ h22, STOPi poiché in 894720256 le cifre pari sono 8 + 4 + 2 + 0 + 2 + 6 = 22. 2. Eseguire una derivazione del sistema costruito a partire dalla configurazione h142, STARTi indicando nella giustificazione di ogni passo di derivazione anche la sostituzione ϑ delle variabili della regola usata.

SOLUZIONE Le configurazioni del sistema, Sp , sono le seguenti: Γp = {hα, STARTi | α ∈ Σ+ } ∪ {hα, ni | α ∈ Σ+ , n ∈ IN } ∪ {hn, STOPi | n ∈ IN } Le configurazioni terminali sono Tp = {hn, STOPi | n ∈ IN }. Poniamo P = {0, 2, 4, 6, 8} e D = {1, 3, 5, 7, 9}. Le regole che definiscono la relazione di transizione →p sono le seguenti: α ∈ Σ+ (r1) hα, STARTi →p hα, 0i α ∈ Σ+ ,

x ∈ P,

m = n + η(x) (r2)

hx α, ni →p hα, mi α ∈ Σ+ ,

x∈D (r3)

hx α, ni →p hα, ni x ∈ P,

m = n + η(x) (r4)

hx, ni →p hm, STOPi x∈D (r5) hx, ni →p hn, STOPi

37

La funzione η è la funzione di valutazione semantica che abbiamo definito per gli alberi della categoria sintattica Num, che contiene anche le stringhe di Σ = Cif. Nel nostro caso la funzione prende una cifra decimale e la mappa nel corrispondente numero naturale. La derivazione, usando il sistema dato, è la seguente:

h142, STARTi →p

{ (r1), ϑ = {142/α} 142 ∈ Σ+ } h142, 0i

→p

{ (r3), ϑ = {1/x, 42/α, 0/n} 42 ∈ Σ+ , 1 ∈ D } h42, 0i

→p

{ (r2), ϑ = {4/x, 2/α, 0/n, 4/m} 2 ∈ Σ+ , 4 ∈ P , 4 = 0 + η(4) } h2, 4i

→p

{ (r4), ϑ = {2/x, 4/n, 6/m} 2 ∈ P , 6 = 4 + η(2) } h6, STOPi

Esercizio 2.14. Si consideri la seguente grammatica: S → abS | bcS | Si definisca un sistema di transizioni S1 = hΓ1 , T1 , →1 i che presa una stringa α ∈ L(S) elimina tutte le occorrenze della sottostringa bb. Ad esempio ababbcbcabbcbc →∗1 abacbcacbc.

SOLUZIONE

38

Esercizio 2.15. Si consideri la seguente grammatica: S → aSb | B B → cB | dB | 39

Si scriva un sistema di transizioni oppure una funzione ricorsiva che, presa α ∈ L(S), calcoli il numero (3 · #a) + (2 · #c), dove #a e #c sono il numero di ’a’ e il numero di ’c’ in α, rispettivamente. Nel caso in cui la stringa α passata al sistema (alla funzione) sia tale che α 6∈ L(S) allora il sistema si deve bloccare (la funzione deve essere indefinita).

SOLUZIONE

3

Semantica Operazionale

Esercizio 3.1. Si supponga di estendere il linguaggio didattico con la seguente produzione: Exp ::= on Exp twice Exp else half 40

L’espressione on E1 twice E2 else half ha come valore il doppio del valore di E2 se l’espressione E1 è vera, la metà del valore di E2 se invece E1 è falsa. Scrivere le regole di →exp che definiscono la semantica operazionale della nuova espressione facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE

Esercizio 3.2. Si supponga di estendere il linguaggio didattico con la seguente produzione: Decl ::= declare Type Ide = Exp if (Exp) else Type Ide = Exp; La dichiarazione declare T1 x1 = E1 if (E2) else T2 x2 = E3; valuta nello stato corrente il valore di E2. Se tale valore è vero allora effettua la dichiarazione T1 x1 = E1, altrimenti effettua la dichiarazione T2 x2 = E3. Scrivere le regole di →dec che definiscono la semantica operazionale della nuova dichiarazione facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE

41

Esercizio 3.3. Si supponga di aggiungere la seguente produzione alla grammatica del linguaggio didattico: Com ::= casemod3 (Exp) Com, Com, Com L’esecuzione del comando casemod3 (E) C0, C1, C2 consiste nel valutare l’espressione E, che deve avere un valore intero. Se tale valore è divisibile per 3 allora deve essere eseguito il comando C0. Se il valore dà resto 1 nella divisione per 3 allora deve essere eseguito il comando C1. Se, infine, il valore dà resto 2 nella divisione per 3 allora deve essere eseguito il comando C2. In tutti e tre i casi lo stato risultante dall’esecuzione del casemod3 è quello che si ottiene dopo l’esecuzione del comando selezionato. Scrivere le regole di →com che definiscono la semantica operazionale del nuovo comando facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE Le regole per il nuovo comando sono le seguenti: hE, σi →exp n,

n mod 3 = 0,

hC0, σi →com σ 0

hcasemod3 (E) C0, C1, C2, σi →com σ 0 hE, σi →exp n,

n mod 3 = 1,


hcasemod3 (E) C0, C1, C2, σi →com σ 0 hE, σi →exp n,

n mod 3 = 2,

(comcasemod3 −0 )

(comcasemod3 −1 )


hcasemod3 (E) C0, C1, C2, σi →com σ 0

42

(comcasemod3 −2 )

Esercizio 3.4. Si supponga di estendere il linguaggio didattico con la seguente produzione: Com ::= rep-if (Exp) Com else Com exit on (Exp) L’esecuzione del comando rep-if (E1) C1 else C2 exit on (E2) corrisponde ad eseguire un ciclo repeat con all’interno un if. All’inizio il corpo del ciclo deve essere eseguito almeno una volta. L’esecuzione del corpo consiste nel valutare la guardia E1 dell’if interno e ad eseguire il comando C1 se risulta vera oppure C2 se risulta falsa. Il ciclo viene fatto ripartire se, nello stato risultante dall’esecuzione del corpo, la guardia di uscita E2 è falsa oppure, se risulta vera, il ciclo termina. Scrivere le regole di →com che definiscono la semantica operazionale del nuovo comando facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE Scriviamo le regole considerando i quattro possibili casi dei valori di verità di E1 ed E2.

hE1, σi →exp tt


hE2, σ 0 i →exp tt

hrep-if (E1) C1 else C2 exit on (E2), σi →com σ 0 hE1, σi →exp ff


(comrep−if −tt−tt )

hE2, σ 0 i →exp tt

hrep-if (E1) C1 else C2 exit on (E2), σi →com σ 0 hE1, σi →exp tt hC1, σi →com σ 00 hE2, σ 00 i →exp ff hrep-if (E1) C1 else C2 exit on (E2), σ 00 i →com σ 0 hrep-if (E1) C1 else C2 exit on (E2), σi →com σ

(comrep−if −ff −tt )

(comrep−if −tt−ff )

0

hE1, σi →exp ff hC2, σi →com σ 00 hE2, σ 00 i →exp ff hrep-if (E1) C1 else C2 exit on (E2), σ 00 i →com σ 0

(comrep−if −ff −ff )

hrep-if (E1) C1 else C2 exit on (E2), σi →com σ 0

Esercizio 3.5. Si consideri lo stato σ0 = ω.{x → 3, y → 0}.{z → 5}.Ω. Si esegua, mostrando la derivazione e le sottoderivazioni, la seguente lista di statements a partire da σ0 tramite il sistema →slist : int y = x + z; x = x + y;

SOLUZIONE 43

44

Esercizio 3.6. Si supponga di estendere il linguaggio didattico con la seguente produzione: Com ::= on Exp define Ide = Exp in Com else Com L’esecuzione del comando on E1 define x = E2 in C1 else C2 comincia con il testare il valore dell’espressione E1 nello stato corrente. Se è falsa viene eseguito il comando C2 e l’esecuzione termina nello stato risultante. Se invece E1 è vera allora viene definita la nuova variabile x a cui viene dato il valore di E2 e quindi nello stato risultante da questa definizione viene eseguito C1. Lo stato risultante dell’intero comando deve contenere gli effetti di C1, ma la x definita deve completamente scomparire. Scrivere le regole di →com che definiscono la semantica operazionale del nuovo comando facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE Utilizziamo due regole che gestiscono i due valori di verità possibili di E1. Il caso false è semplice. Per il caso true appiliamo allo stato corrente un frame vuoto nuovo, dove inseriamo la x, per valutare C1. Dopo la valutazione semplicemente buttiamo via il frame precedentemente inserito per la x.

hE1, σi →exp ff


hon E1 define x = E2 in C1 else C2), σi →com σ 0 hE1, σi →exp tt

hE2, σi →exp v

(comon−ff )

hC1, ω[v /x ].σi →com ϕ.σ 0

hon E1 define x = E2 in C1 else C2, σi →com σ 0

(comon−tt )

Esercizio 3.7. Si supponga di estendere il linguaggio didattico con la seguente produzione: Com ::= mod3while (Exp) Com Com L’esecuzione del comando mod3while (E) C1 C2 corrisponde ad eseguire un ciclo simile al while, ma la cui guardia E deve essere una espressione il cui valore è un numero naturale n. Al momento del controllo della guardia il ciclo termina se il valore di n è divisibile per 3. Se invece il valore di n dà resto 1 nella divisione per 3 allora viene eseguito il comando C1 e il ciclo viene fatto ripartire. Infine, se il valore di n dà resto 2 nella divisione per 3 allora viene eseguito il comando C2 e il ciclo viene fatto ripartire. Scrivere le regole di →com che definiscono la semantica operazionale del nuovo comando facendo riferimento al modello in cui lo stato è composto solo da una pila di frame. 45

SOLUZIONE Scriviamo le regole sulla falsariga di quelle del while, adattandole ai tre casi possibili di valori numerici di E.

hE, σi →exp n

n mod 3 = 0

hmod3while (E) C1 C2, σi →com σ hE, σi →exp n n mod 3 = 1 00 hC1, σi →com σ hmod3while (E) C1 C2, σ 00 i →com σ 0

(commod3while−uscita )

(commod3while−ciclo1 )

hmod3while (E) C1 C2, σi →com σ 0

hC2, σi →com

hE, σi →exp n n mod 3 = 2 00 σ hmod3while (E1) C1 C2, σ 00 i →com σ 0

(commod3while−ciclo2 )

hmod3while (E) C1 C2, σi →com σ 0

Esercizio 3.8. Si supponga di estendere il linguaggio didattico con la seguente produzione: Com ::= dofor Com iterate Com while (Exp); Il comando dofor C1 iterate C2 while (E) è un ciclo che esegue il corpo C1 almeno una volta e, ogni volta che esegue il corpo, esegue anche il comando di iterazione C2. Nello stato risultante dopo l’esecuzione del corpo e dell’iterazione viene controllato il valore della guardia E. Se E è falsa allora il ciclo esce, se invece E è vera allora il ciclo riparte. Scrivere le regole di →com che definiscono la semantica operazionale del nuovo comando facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE

46

Esercizio 3.9. Si supponga di aggiungere la seguente produzione alla grammatica del linguaggio didattico: Decl ::= declareif Type Ide (Exp) then Exp else Exp L’esecuzione della dichiarazione declareif T x (E) then E1 else E2 consiste nel dichiarare la nuova variabile x nel frame corrente. Il valore con cui inizializzare la nuova variabile dipende dal valore di E. Se E è vera allora il valore di inizializzazione di x sarà quello di E1; se E è falsa allora il valore sarà quello di E2. Scrivere le regole di →dec che definiscono la semantica operazionale della nuova dichiarazione facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE Le regole per la nuova dichiarazione sono le seguenti: σ = ϕ.σ 00 ,

hE, σi →exp tt,

hE1, σi →exp v,

σ 0 = ϕ[v /x ].σ 00

hdeclareif T x (E) then E1 else E2, σi →dec σ 0 σ = ϕ.σ 00 ,

hE, σi →exp ff,

hE2, σi →exp v,

σ 0 = ϕ[v /x ].σ 00

hdeclareif T x (E) then E1 else E2, σi →dec σ 0

47

(decif −tt )

(decif −ff )

Esercizio 3.10. Si supponga di estendere il linguaggio didattico con la seguente produzione: Com ::= xwhile (Exp, Exp) Com L’esecuzione del comando xwhile (E1, E2) C corrisponde ad eseguire un ciclo simile al while, ma la cui guardia dipende dalle due espressioni E1 ed E2. Il ciclo deve terminare se le due espressioni hanno lo stesso valore di verità (cioè sono entrambe vere o entrambe false), mentre il ciclo deve continuare con un’altra iterazione (eseguendo quindi il comando C) se le due espressioni hanno valore di verità diverso (cioè una è vera e l’altra è falsa, o viceversa). Scrivere le regole di →com che definiscono la semantica operazionale del nuovo comando facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE Scriviamo le regole sulla falsariga di quelle del while, adattandole ai quattro casi possibili di valori di verità di E1 ed E2. Utilizziamo b1 e b2 come metavariabili per valori di verità nell’insieme {tt, ff }.

hE1, σi →exp b1

hE2, σi →exp b2

b1 = b2

hxwhile (E1, E2) C, σi →com σ hE1, σi →exp b1 hE2, σi →exp b2 b1 6= b2 00 00 hC, σi →com σ hxwhile (E1, E2) C, σ i →com σ 0

(comxwhile−uscita )

(comxwhile−ciclo )

hxwhile (E1, E2) C, σi →com σ 0

Esercizio 3.11. Si supponga di estendere il linguaggio didattico con la seguente produzione: Decl ::= Type Ide = Exp ? Exp : Exp; La dichiarazione T x = E1 ? E2 : E3 dichiara una nuova variabile x nel frame corrente. Il valore con cui inizializzare la nuova x è calcolato nel modo seguente: se E1 è vera allora il valore di x deve essere il valore di E2; se E1 è falsa allora il valore di x deve essere il valore di E3. Scrivere le regole di →dec che definiscono la semantica operazionale della nuova dichiarazione facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE Le regole per la nuova dichiarazione sono le seguenti:

48

σ = ϕ.σ 0 hE1, σi →exp tt hE2, σi →exp v σ 00 = ϕ[v /x ].σ 0 hT x = E1 ?

E2 :

(dec?−tt )

E3, σi →dec σ 00

σ = ϕ.σ 0 hE1, σi →exp ff hE3, σi →exp v σ 00 = ϕ[v /x ].σ 0 hT x = E1 ?

E2 :

(dec?−ff )

E3, σi →dec σ

00

Esercizio 3.12. Si supponga di estendere il linguaggio didattico con la seguente produzione: Decl ::= Type Ide = Exp given Exp; Una dichiarazione T x = E1 given E2; ha come effetto di dichiarare nel frame corrente una nuova variabile x inizializzata con il valore di E1 se l’espressione E2 è vera nello stato corrente, oppure inizializzata con ω se l’espressione E2 è falsa nello stato corrente. Scrivere le regole di →dec che definiscono la semantica operazionale della nuova dichiarazione facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE Scriviamo le regole sulla falsariga di quelle per le normali dichiarazioni. Avremo da gestire i due casi in cui E2 è vera o falsa. Pertanto, come al solito, faremo due regole per lo stesso caso sintattico.

hE2, σi →exp ff

σ = ϕ.σ 00

σ 0 = ϕ[$ /x ].σ 00 (decgiven−ff )

hT x = E1 given E2, σi →dec σ 0 hE2, σi →exp tt

σ = ϕ.σ 00

hE1, σi →exp v

hT x = E1 given E2, σi →dec σ 0

σ 0 = ϕ[v /x ].σ 00 (decgiven−tt )

Esercizio 3.13. Si supponga di estendere il linguaggio didattico con la seguente produzione: Com ::= do Com while (Exp) then Com

49

Il comando do C1 while (E) then C2 è un ciclo seguito da un comando finale. Viene dapprima eseguito il comando C1 e, nello stato risultante, viene valutata l’espressione E. Se il valore di E è vero allora il ciclo riparte. Se il valore di E è falso allora il ciclo termina eseguendo il comando C2 e portandosi, quindi, nello stato finale. Scrivere le regole di →com che definiscono la semantica operazionale del nuovo comando facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE Le regole per il nuovo comando sono le seguenti: hC1, σi →com σ 0 , hE, σ 0 i →exp tt, hdo C1 while (E) then C2, σ 0 i →com σ 00 hdo C1 while (E) then C2, σi →com σ hC1, σi →com σ 0 ,

(comdothen−tt )

00

hC2, σ 0 i →com σ 00

hE, σ 0 i →exp ff,

hdo C1 while (E) then C2, σi →com σ 00

(comdothen−ff )

Esercizio 3.14. Si supponga di estendere il linguaggio didattico con la seguente produzione: Com ::= rwhile (Exp) on (Exp) Com Com else reverse Il comando rwhile (E1) on (E2) C1 C2 else reverse è un ciclo che ha come guardia l’espressione E1. Quando E1 è falsa il ciclo esce, mentre quando è vera si deve entrare nel ciclo. L’esecuzione del corpo del ciclo avviene come segue: si valuta il valore di E2. Se questo è vero vengono eseguiti in sequenza i comandi C1 e C2, dopodiché il ciclo riparte. Se il valore di E2 è falso allora vengono eseguiti in sequenza i comandi C2 e C1, dopodiché il ciclo riparte. Scrivere le regole di →com che definiscono la semantica operazionale del nuovo comando facendo riferimento al modello in cui lo stato è composto solo da una pila di frame.

SOLUZIONE

50

Esercizio 3.15. Dimostrare formalmente che i seguenti comandi sono equivalenti, in maniera debole, se eseguiti a partire dallo stato σ0 = {x 7→ 2, y 7→ 1}.Ω C1: if (x > y) x = y; else y = x; C2: while (x > y) x = x - y;

SOLUZIONE Eseguo due derivazioni dei due comandi a partire dallo stato σ0 . Se lo stato risultante dalle derivazioni è lo stesso allora i comandi sono debolemente equivalenti. Derivazione di C1: hif (x > y) x = y; else y = x;, σ0 i →com

{ (comif −tt ), E[[x > y]]σ0 = tt, (com= ): E[[y]]σ0 = 1, hx = y;, σ0 i →com σ0 [1 /x ]} σ0 [1 /x ]

51

Derivazione di C2: hwhile (x > y) x = x - y;, σ0 i →com

{ (comwhile−tt ), E[[x > y]]σ0 = tt, (com= ): E[[x - y]]σ0 = 1, hx = x − y;, σ0 i →com σ0 [1 /x ], (d1): hwhile (x > y) x = x - y;, σ0 [1 /x ]i →com σ0 [1 /x ]} σ0 [1 /x ]

dove la derivazione (d1) è la seguente: (d1): hwhile (x > y) x = x - y;, σ0 [1 /x ]i →com

{ (comwhile−ff ), E[[x > y]]σ0 [1 /x ] = ff } σ0 [1 /x ]

Gli stati risultanti sono identici, pertanto i due comandi sono debolmente equivalenti.

Esercizio 3.16. Si dimostri formalmente che i seguenti comandi sono equivalenti, in maniera debole, a partire dallo stato σ0 = {x → 1, y → 1}.Ω. C1: while (x > 0) x = x - y; C2: x = 0;

SOLUZIONE Eseguiamo prima una derivazione per C1:

hwhile (x > 0) x = x - y;, σ0 i →com

{ (comwhile−tt ), E[[x > 0]]σ0 = tt, (com= ): E[[x - y]]σ0 = 0, hx = x - y;, σ0 i →com σ0 [0 /x ], (d1): hwhile (x > 0) x = x - y;, σ0 [0 /x ]i →com σ0 [0 /x ] } σ0 [0 /x ]

dove la sottoderivazione d1 è la seguente:

52

(d1) : hwhile (x > 0) x = x - y;, σ0 [0 /x ]i →com

{ (comwhile−ff ), E[[x > 0]]σ0 = ff } σ0 [0 /x ]

Eseguiamo ora una derivazione per l’altro comando:

hx = 0;, σ0 i →com

{ (com= ), E[[0]]σ0 = 0 } σ0 [0 /x ]

In entrambi i casi lo stato di arrivo è lo stesso, quindi i due comandi sono equivalenti, in maniera debole, a partire dallo stato σ0 .

4

Programmazione Procedurale e su Sequenze

Esercizio 4.1. Si completi la definizione del seguente metodo: \** Cerca il primo elemento di un array di interi che e ` divisibile per un numero dato. @param a array di interi @param b numero intero @return la posizione del primo elemento di a che e ` divisibile per b, -1 se tale elemento non esiste */ public int searchDiv(int[] a, int b)

SOLUZIONE

53

Esercizio 4.2. Completare la definizione del seguente metodo: 54

/** * Controlla se tutti gli elementi di un array sono minori o * uguali del valore massimo di un altro array. * @param a array di interi * @param b array di interi * @return true se tutti gli elementi di b sono minori o uguali * del valore massimo dell’array a, false altrimenti */ public boolean checkMax(int[] a, int[] b)

SOLUZIONE public boolean checkMax(int[] a, int[] b){ // Cerco il massimo in a int max = a[0]; for (int i = 1; i < a.length; i++) if (a[i] > max) max = a[i]; // Cerco il primo elemento di b che ` e maggiore del massimo boolean trovato = false; int j = 0; while (j < b.length && !trovato) if (b[j] > max) trovato = true; else j++; if (trovato) // Esiste un elemento di b maggiore del massimo di a return false; else return true; }

Esercizio 4.3. Si completi la definizione del seguente metodo: /** * Controlla se due porzioni di array sono uguali. * @param a, b due array di interi * @param startA, stopA gli estremi dell’intervallo di a da controllare * @param startB, stopB gli estremi dell’intervallo di b da controllare * @return true se i due array, negli intervalli specificati, contengono * esattamente gli stessi elementi. False in tutti gli altri * casi, anche quando gli intervalli hanno lunghezza diversa o * escono dai limiti della dimensione degli array */ public boolean checkEqual(int [] a, int [] b, int startA, int stopA, int startB, int stopB) 55

SOLUZIONE public boolean checkEqual(int [] a, int [] b, int startA, int stopA, int startB, int stopB){ // Controlla se gli indici rientrano nelle dimensioni degli array // e se sono consistenti (start viene prima o e ` uguale a stop) if (startA < 0 || stopA >= a.length || startB < 0 || stopB >= b.length || startA > stopA || startB > stopB) return false; // Controllo di lunghezza identica di intervallo if ((stopA - startA) != (stopB - startB)) return false; // Ricerca lineare incerta del primo elemento diverso nell’intervallo int i = startA; int j = startB; boolean trovato = false; while (i i_stop) */ public static boolean m(int[] a, int i_start, int i_stop)

SOLUZIONE

5

Classi, Oggetti, Metodi

Esercizio 5.1. Si consideri il seguente programma scritto nel linguaggio didattico: 62

prog { class Fie { public int y; public boolean q; public int z; public void m(int y, int z){ if (this.q) this.y = this.y + y; else this.z = this.z + z; this.q = !this.q; if (this.y < this.z) this.y = this.z; }} (1) { Fie a = new Fie; Fie b = new Fie; int y = 2; int z = 0; a.y = 4; a.z = a.y + y: boolean q = a.y == y || y < 3; a.q = q && z + y < a.y; b.y = a.y - y; b.z = a.z + z; b.q = !a.q; (2) a.m(y,z); y = y + a.y; z = z + y; b.m(b.z, a.y); (3) }} Disegnare l’ambiente statico delle classi nel punto (1) del programma e disegnare la pila di frame e lo heap nei punti del programma (2) e (3).

SOLUZIONE

63

64

Esercizio 5.2. Si consideri il seguente programma scritto nel linguaggio didattico: prog{ class Foo { public int x; public int z; public void meth(int x, int z, boolean b){ if (b) { this.x = this.x + x; this.z = this.z + z + this.x; } else if (this.x > x) this.z = this.z + this.x; else { this.x = this.x + x; this.z = this.z + z; } this.x = this.x - 1; } } (1) { int x = 3; int y = 4; int z = 5; boolean b = x > y || z > y; Foo o = new Foo; Foo a = o; a.x = x + y; o.z = z + o.x; Foo c = new Foo; c.x = a.z % 5; c.z = c.x + o.x; (2) a.meth(o.x + x, c.z + z, !b); y = y + x + z; c.meth(x, y, o.z > y); (3) }} Disegnare l’ambiente statico delle classi nel punto (1) del programma e disegnare la pila di frame e lo heap nei punti del programma (2) e (3).

SOLUZIONE

65

66

Esercizio 5.3. Si consideri il seguente programma scritto nel linguaggio didattico: prog { class Elem { public int x; public int z; public void m(int x, int z){ if (this.x > x) this.x = x + z; else if (this.z >= z) this.z = this.z - x + this.x * z; else { this.z = this.x + z + x; this.x = this.x + this.z; } }} (1) { Elem p = new Elem; p.x = 4; p.z = 7; int x = 3; int z = p.x + x; Elem q = new Elem; q.x = x; q.z = z; Elem r = p; (2) p.m(q.x - x, r.z + 2); x = x + z; q.m(r.z + x, 2 * z); (3) }} Disegnare l’ambiente delle classi ρc al punto (1) del programma. Disegnare la pila di frame e lo heap nei punti del programma (2) e (3).

SOLUZIONE L’ambiente delle classi:

ρ c

Elem {x −> ω ,

ρm

m

z −> ω

}

ρm

{if (this.x > x)) ....... (x,z) this.x = this.x + this.z;}}

Lo stato al punto (2):

67

σ r q z x p

Elem

ζ

x −> 4 z −> 7

−> −> −> 7 −> 3 −>

Elem x −> 3 z −> 7


σ r q z x p

Elem

ζ

x −> 9 z −> 7

−> −> −> 7 −> 10 −>

Elem x −>37 z −>34

Esercizio 5.4. Si consideri il seguente programma scritto nel linguaggio didattico: prog { class Fie { public int y; public Fie x; public Fie search(int y){ boolean trovato = false; Fie x = this; while (x != null && !trovato) if (x.y == y) trovato = true; else x = x.x; return x; } } 68

{ Fie x = new Fie; x.y = 3; x.x = new Fie; x.x.y = 4; x.x.x = null; Fie x1 = x.search(4); (1) x1.x = new Fie; x1.x.y = 10; x1.x.x = null; Fie x2 = x1.search(10); Fie x3 = x.search(x.y + x1.y); (2) }} Disegnare la pila di frame e lo heap nei punti del programma (1) e (2).

SOLUZIONE Lo stato al punto (1):

σ

ζ Fie y −> 3 x −>

x1 −> x −>

Fie y −> 4 x −> null


σ

ζ Fie y −> 3 x −>

x3−>null x2 −> x1 −> x −>

Fie y −> 4 x −> Fie y −> 10 x −> null 69

Esercizio 5.5. Si consideri il seguente programma scritto nel linguaggio didattico: prog { class Foo { public int z; public boolean r; public void m(int z, boolean r){ if (this.r) { this.z = z; this.r = r; } else { this.z = this.z + z; this.r = this.r || r; } } } (1) { Foo o = new Foo; int z = 7; int x = 4; o.r = x < 3 || z > 1; boolean r = true; o.m(x + z, !r); (2) Foo a = o; x = z + a.z; a.m(z + x - 1, r && z < x); (3) } } Disegnare l’ambiente delle classi ρc al punto (1) del programma. Disegnare la pila di frame e lo heap nei punti del programma (2) e (3).

SOLUZIONE L’ambiente delle classi è il seguente:

ρ c

Foo

{z −> ω r −> ω }

ρ m

ρ m

{ if (this.r) ... m

z, r this.r || r; } }

70

Lo stato al punto (2) è il seguente:

σ

ζ Foo z −> 11 r −> ff

r −> tt x −> 4 z −> 7 o Lo stato al punto (3) è il seguente:

σ

ζ Foo z −> 35

a r −> tt x −> 18 z −> 7 o

r −> tt

Esercizio 5.6. Si consideri il seguente programma scritto nel linguaggio didattico: prog { class Adder { public int x; public int y; public void add(int x, int y, boolean b){ if (this.x >= y) this.x = this.x + y; else if (this.y >= x) this.y = this.y + x; else if (b) { this.x = this.x + x; this.y = this.y + y; } else { this.x = this.x + this.y; this.y = this.y + this.x; } }} { Adder a = new adder; int x = 3; int y = 5; 71

boolean b = !(x > 2 && y < 5); a.x = x + 1; a.y = x + y; a.add(a.x + y, a.y + x, b); (1) x = x + a.x; y = y + x; b = x > y; Adder c = a; c.add(y, x + 4, b); (2) }} Disegnare la pila di frame e lo heap nei punti del programma (1) e (2).

SOLUZIONE Lo stato al punto (1) è il seguente:

σ

ζ Adder x −> 13 y −> 19

b −> tt y −> 5 x −> 3 a Lo stato al punto (2) è il seguente:

σ

ζ Adder x −> 32

c b −> ff y −> 21 x −> 16 a

y −> 51

Esercizio 5.7. Si consideri il seguente programma scritto nel linguaggio didattico: prog { class Fie { public int x; public boolean b; public void met(int x){ if (this.x == x || this.b) 72

this.x = x + 5; else { this.x = x; this.b = !this.b; } this.x = this.x + 2 * x; }} (1) { Fie a = new Fie; a.x = 4; int x = 3; boolean b = a.x > x; a.b = !b; Fie c = a; (2) c.met(a.x + 3 * x); x = x + 1; a.met(c.x + x); (3) }} Disegnare l’ambiente delle classi ρc al punto (1) del programma. Disegnare la pila di frame e lo heap nei punti del programma (2) e (3).

SOLUZIONE L’ambiente delle classi:

ρ c

Fie

ρm

{x −> ω ,

met

x

b −> ω

}

ρm

{if (this.x == 0 || this.b) ....... this.x = this.x + 2 * x; }


σ

ζ

c b −> tt x −> 3 a

Fie x −> 4 b −> ff


73

σ

ζ

c b −> tt x −> 4 a

Fie x −> 134 b −> tt

Esercizio 5.8. Si consideri il seguente programma scritto nel linguaggio didattico: prog{ class Fie { public int x; public boolean b; public void m(int x, int y, boolean b){ if (b) while (x > 0) { this.x = this.x + y; x = x - 1; } else while (x < 3) { this.x = this.x + (y / 2); x = x + 1; } if (this.b != b) this.b = b; } } (1) { int x = 2; int y = 4; boolean b = (y % x) == 0; Fie a = new Fie; Fie b = new Fie; Fie c = a; Fie d = b a.x = x * y; b.x = a.x * x; c.b = a.x > x || b.x < x; d.b = a.x > b.x; (2) d.m(a.x - 6, y, b); x = x - 1; c.m(x, x + y, !d.b); (3) }} 74

Disegnare l’ambiente statico delle classi nel punto (1) del programma e disegnare la pila di frame e lo heap nei punti del programma (2) e (3).

SOLUZIONE

75

76

Esercizio 5.9. Si consideri il seguente programma scritto nel linguaggio didattico: prog { class Foo { public int x; public Foo next; public void met(int x){ Foo s = new Foo; s.x = this.x; s.next = this.next; this.x = x; this.next = s; } } { int x = 2 Foo s = new Foo; s.x = x + 1; s.next = null; s.met(4); x = x + s.next.x; (1) s.next.met(x + 1); s.next.met(s.x + x + s.next.next.x); (2) }} Disegnare la pila di frame e lo heap nei punti del programma (1) e (2).

SOLUZIONE Lo stato al punto (1):

σ

ζ Foo

s −> x −> 5

x −> 4 next −>

Foo x −> 3 next −> null

77


σ

ζ Foo

s −> x −> 5

Foo

x −> 4

x −> 12

next −>

next −>

Foo

Foo

x −> 3

x −> 6

next −> null

next −>

Esercizio 5.10. Si consideri il seguente programma scritto nel linguaggio didattico: prog { class Fie { public int y; public boolean p; public void m(int y, boolean p){ if (this.y < y) this.y = y + 3; else if (p) this.y = this.y - y; else this.y = this.y % 3; this.p = p; }} (1) { Fie a = new Fie; int y = 7; a.y = y + 1; boolean p = a.y > y && y > 7; a.p = !p; Fie b = new Fie; b.y = a.y - 1; b.p = p || a.p; Fie c = a; (2) b.m(c.y, p); y = y + b.y; c.m(y - 10, b.p); (3) }} 78

Disegnare l’ambiente delle classi ρc al punto (1) del programma. Disegnare la pila di frame e lo heap nei punti del programma (2) e (3).

SOLUZIONE L’ambiente delle classi è il seguente:

ρ c

Fie

{y −> ω p −> ω }

ρ m

ρ m

{ if (this.y < y) ... m

y, p this.p = p; }


ζ

σ

Fie y −> 8 p −> tt

Fie c b p y a

−> −> −> ff −> 7 −>

y −> 7 p −> tt


ζ

σ

Fie y −> 2 p −> ff

Fie c b p y a

−> −> −> ff −> 18 −>

y −> 11 p −> ff

79