Scritto di Algoritmi e sd (1o anno) 18 Gennaio 2008

0001110011 000011101 10000111 01110011 1011110 11110111 00010101 1010111 101010101010 0110001111 10111100 0011101 11000
0000 0011010101 100110 111010 1011 1001011 101111 000 111001 1101100 01011101 101100011 1011101110 110111000 0101010100
Scritto di Algoritmi e s.d.
(1o anno)
18 Gennaio 2008
RISPOSTE
COGNOME:
________________________________________________
NOME:
________________________________________________
Esercizio 1
VOTO:
Esercizio 2
VOTO:
a)
b)
Esercizio 5
c)
solo parte a
sorte
insieme
Il resto su protocollo, ordinatamente.
1
0001110011 000011101 10000111 01110011 1011110 11110111 00010101 1010111 101010101010 0110001111 10111100 0011101 11000
0000 0011010101 100110 111010 1011 1001011 101111 000 111001 1101100 01011101 101100011 1011101110 110111000 0101010100
Scritto di Algoritmi e s.d.
Esercizio 1
(1o anno)
18 Gennaio 2008
(punti 5 in prima approssimazione)
Consideriamo le seguenti dichiarazioni:
type
List = puntatore a Nodo
Nodo =
record
cont : integer
succ : List
end
procedura ppp ( lis : List IN)
if (lis non è nullo)
then
}
}
Domanda:
lis
{
{
ppp(lis->next)
if (lis->next non è nullo) then ppp( lis->next->next)
scrivi (lis->cont) ; scrivi(" ; " )
qual'è l'output della chiamata ppp(lis) se lis
è la lista che segue ?
---> 1 ---> 2 ---> 3 ---> 4 ---> 5
Esercizio 2 (punti 3 in prima approssimazione)
Consideriamo espressioni definite come segue. Usiamo due insiemi di "base":
Lett = {a, b, ..., z} , l'insieme delle lettere minuscole, e
LETT = {A, B, ...., Z} , l'insieme delle lettere maiuscole,
ed un insieme ausiliario: Atom, dato dalla seguente definizione (induttiva):
• [1]
(base)
LETT ⊂ Atom
• [2]
(passo)
se x ∈ Lett e w ∈ Atom
allora
x w ∈ Atom
(x w = aggiungere x in testa a w)
L'insieme Exp delle espressioni è dato dalla seguente definizione (induttiva):
• [3]
(base)
Atom ⊂ Exp
• [4]
(passo 1)
se e1, e2 ∈ Exp
allora:
e1 e2 $ ∈ Exp
• [5]
(passo 2)
se e ∈ Exp
allora:
e # ∈ Exp
Domande:
a) la stringa
aaaaX Y $
appartiene ad Exp ?
(risposta : SI' / NO)
b) la stringa
X # baba $
appartiene ad Exp ?
(risposta : SI' / NO)
c) scrivere una stringa di Exp di lunghezza > 10 e contenente almeno un $ ed un #
Esercizio 3
(punti 5 in prima approssimazione)
Consideriamo il seguente algoritmo (che non fa nulla di interessante)
var
dim : integer
leggi (dim)
2
0001110011 000011101 10000111 01110011 1011110 11110111 00010101 1010111 101010101010 0110001111 10111100 0011101 11000
0000 0011010101 100110 111010 1011 1001011 101111 000 111001 1101100 01011101 101100011 1011101110 110111000 0101010100
{
blocco con dichiarazioni
var
aa : array [1 .. dim] of integer
k, j, n: integer
per n = 1, 2, 3, ...., dim : leggi(aa[n])
k <--- dim
while k > 0 do
{
n <--- k div 2
if
then
}
aa[n] > 0
per j = 1, 2, 3, ...., n : aa[j] <--- aa[j] * aa[j]
k<--- k div 2
}
Domanda:
Calcolare la complessità dell'algoritmo, nel caso peggiore, in funzione di dim.
Possibilmente dare la stima in Θ( ... ). Non fare conti troppo dettagliati (esplicitando tutte le
costanti,....), ma non limitarsi nemmeno a dare il risultato, o a quattro chiacchere; in
particolare, precisare se c'è un caso peggiore (o caso pessimo) e qual'è.
Esercizio 4 (punti 7 in prima approssimazione)
Consideriamo alberi con apertura al piu' 3 e con etichette intere. Vogliamo una
procedura/funzione per passare dall'implementazione con record con 3 puntatori ai figli
all'implementazione figlio sinistro - fratello destro. Per fissare le idee:
type
Alb3 =
Nodo3 =
puntatore a Nodo3
Record
cont : intero
uno, due, tre : Alb3
end
AlbFF =
NodoFF =
puntatore a NodoFF
Record
cont : intero
figlio, frate : AlbFF
end
Notare che in un nodo di un albero di tipo Alb3: se il campo uno è nullo, allora sono nulli anche
gli altri; se il campo due è nullo allora anche tre è nullo.
Domanda
Scrivete una procedura/funzione che preso tt di tipo Alb3 produce il corrispondente albero di
tipo AlbFF, senza modificare tt.
Se scrivete una funzione, allora questa deve avere un solo parametro: tt.
Se scrivete una procedura, allora questa deve avere due soli parametri: tt e ttff (il risultato).
Se scrivete in C, traducete le dichiarazioni di sopra.
Esercizio 5 (punti 10 in prima approssimazione)
Consideriamo il tipo di dato "amici-nemici", definito informalmente come segue.
Dato un intero n, si considera un "gruppo di n persone"; due persone del gruppo possono essere
amiche, nemiche, o 'indifferenti" (ne' amiche, ne' nemiche).
Ovviamente:
• se x è amico [ nemico ] di y allora y è amico [ nemico ] di x;
• x ed y non possono essere sia amici che nemici.
3
0001110011 000011101 10000111 01110011 1011110 11110111 00010101 1010111 101010101010 0110001111 10111100 0011101 11000
0000 0011010101 100110 111010 1011 1001011 101111 000 111001 1101100 01011101 101100011 1011101110 110111000 0101010100
Inoltre si devono rispettare le seguenti regole:
1. gli amici degli amici non possono essere nemici
cioè: se (x ed y sono amici) e (y e z sono amici) allora (x e z non possono essere nemici)
2. i nemici degli amici non possono essere amici
3. gli amici dei nemici non possono essere amici
Le operazioni sono:
•
gruppo( n )
forma un gruppo di n persone, indichiamole con 1, 2, 3, ...., n,
dove non ci sono ne' amici, ne' nemici
•
amici (g, x, y)
x ed y diventano amici, se le regole lo permettono;
(altrimenti non succede nulla)
qui g è un gruppo ed x, y sono persone del gruppo
•
nemici (g, x, y)
x ed y diventano nemici, se le regole lo permettono; (altrimenti: nulla)
qui g è un gruppo ed x, y sono persone del gruppo
•
rompi(g, x, y)
se x ey erano amici [nemici], si rompe l'amicizia [inimicizia], ma senza
"passare dall'altra parte" (non diventano nemici [amici])
qui g è un gruppo ed x, y sono persone del gruppo
•
importa(g, x, y)
gli amici di y diventano amici anche di x
ma solo se x ed y erano amici (altrimenti non si fa nulla)
inoltre bisogna verificare le regole per ogni persona da importare
qui g è un gruppo ed x, y sono persone del gruppo
•
situazione(g, x)
produce elenchi (separati) degli amici e dei nemici di x
qui g è un gruppo ed x e una persona del gruppo
Domande:
a) Precisate le sorti di questo tipo di dato (scegliete dei nomi ragionevoli), e per ciascuna sorte
l'insieme corrispondente.
sorte
insieme
b) Descrivere, a parole, con disegni,..., un'implementazione degli oggetti; tale implementazione
deve tener conto delle varie operazioni (cercando di renderle "facili").
c) Scrivere (in modo coerente a sopra) e precisando tipi ed altro, un'implementazione
dell'operazione amici e dell'operazione importa.
4