esercizi File

Informatica
compendio di esercizi
Alessio Plebe
e-mail: [email protected]
1
Macchina di Turing
Gli esercizi sono all’incirca in ordine progressivo di difficoltà. Quelli contrassegnati con un asterisco sono
particolarmente difficili, il lettore non si preoccupi se non riesce a risolverli. Notare che, come in generale
nella programmazione, non vi è necessariamente una sola TM che risolve un problema, quindi negli
esercizi in cui è richiesto di costruire una TM, il risultato potrà anche essere differente dalla soluzione
indicata, senza per questo essere erroneo.
T.1
Calcola il nastro di I/O finale, dato quello di partenza, e la TM
⇓
A
STATO
INPUT
0
0
1
1
2
A
B
A
B
-
T.2
B
NUOVO
STATO
1
1
2
2
-
OUTPUT
⇒
⇒
-
B
A
-
Calcola il nastro di I/O finale, dato quello di partenza, e la TM
⇓
G
STATO
INPUT
0
0
1
1
2
2
3
4
G
B
G
B
G
B
-
T.3
CASELLA
NUOVO
STATO
1
1
2
2
4
3
4
-
G
CASELLA
OUTPUT
⇒
⇒
⇐
⇒
⇐
-
B
B
G
-
Questa TM contiene un loop, e quindi potrebbe continuare all’infinito, sai dire qual’è la condizione che
la ferma?
STATO
INPUT
0
0
1
1
2
x
o
x
o
-
NUOVO
STATO
1
0
1
2
-
CASELLA
OUTPUT
⇒
⇒
⇒
-
o
x
o
-
1
T.4
Verifica, per ciascuno dei tre nastri di I/O, se la TM si ferma
p
p
⇓
u
p
p
STATO
INPUT
0
0
1
1
2
2
3
p
u
p
u
p
u
-
⇓
p
∗
u
NUOVO
STATO
1
2
0
2
3
0
-
p
⇓
p
p
u
CASELLA
OUTPUT
⇒
⇒
⇐
⇐
-
u
p
u
u
p
-
p
T.5
Scrivi una TM che calcoli la disgiunzione logica tra due termini (la disgiunzione, che corrisponde più o meno
all’italiano “oppure”, risulta falsa solo se entrambi gli operandi sono falsi, vera in tutti gli altri casi)
T.6
Scrivi una TM i cui simboli possibili sono M/F, che cambi tutti gli M in F, andando verso destra, e
fermandosi quando ha incontrato tre F di seguito.
T.7
∗
Scrivi una macchina di Turing i cui simboli possibili sono 0/1, che spostandosi verso destra trasformi
sequenze 01 in 10 e viceversa, lasci invariate sequenze 11, e termini alla prima sequenza 00 .
2
21
Architettura dei computer
Gli esercizi sono all’incirca in ordine progressivo di difficoltà. Quelli contrassegnati con un asterisco
sono particolarmente difficili, il lettore non si preoccupi se non riesce a risolverli. Notare che, come in
generale nella programmazione, non vi è necessariamente una sola soluzione a un problema, quindi negli
esercizi in cui è richiesto di costruire una porzione di assembler, il risultato potrà anche essere differente
dalla soluzione indicata, senza per questo essere erroneo.
A.1
Calcola la situazione finale, dopo l’esecuzione di questo frammento di assembler
RAM
CPU
1000
mov $100A R1
1001
mov 20
1002
add R2 R1
1003
mov R1 $1007
R2
R1
744
R2
820
....
R3
0
....
1006
343234
1007
10003
1008
0
1009
400000
100A
80
100B
325
100C
67588567
PC
1000
PS
A.2
Calcola la situazione finale, dopo l’esecuzione di questo frammento di assembler
RAM
CPU
1000
1001
mov −10
R2
1002
add −20
R3
1003
add R2
R3
1006
mov R3 $100D
R1
744
R2
820
R3
0
....
....
PC
1000
PS
A.3
mov $100A R3
100A
130
100B
0
100C
400000
100D
80
100E
325
100F
67588567
Calcola la situazione finale, dopo l’esecuzione di questo frammento di assembler
RAM
CPU
100E
mov $200F R2
100F
add R2
1010
mov R2 $200E
R2
R1
0
1011
add R2
R2
820
1012
mov R2 $200D
R3
10000
....
....
PC
PS
100E
R2
200A
130
200B
0
200C
400000
200D
80
200E
325
200F
4
3
A.4
Calcola il contenuto della locazione di RAM 100B dopo l’esecuzione di questo frammento di assembler
RAM
CPU
1000
add
1001
jmpz
$1004
1002
add
R1 R2
−1 R1
R1
5
1003
jmp
$1000
R2
0
1004
mov
R2 $100B
R3
3
....
1005
PC
1000
Z
PS 0 0 0 0 0 0 0 0 0 0
1006
1007
1008
1009
A.5
100A
3
100B
4
Sai dire se la CPU in queste condizioni può trovarsi in un loop infinito, e spiegare la tua risposta?
RAM
CPU
R1
10
1000
mov
1 R2
1001
mov
$100A R1
1002
add
−1 R1
1003
mov
R2 R3
R2
20
1004
jmpz
$1006
R3
3
....
1005
jmp
$1002
1006
mov
R2 $100B
PC
1000
Z
PS 0 0 0 0 0 0 0 0 0 0
1007
1008
1009
A.6
∗
100A
3
100B
4
Calcola il contenuto della locazione di RAM 100B
RAM
CPU
R1
10
FFF
mov
$100A R2
1000
mov
0
1001
mov
R2
R1
1002
add
R1
R3
R1
R2
20
1003
add
−1
R3
3
....
1004
jmpz
$1006
1005
jmp
$1002
1006
add
−1
1007
jmpz
$1009
1008
jmp
$1001
1009
mov
PC
FFF
Z
PS 0 0 0 0 0 0 0 0 0 0
A.7
A.8
A.9
∗
R3
R2
R3 $100B
100A
3
100B
4
Calcola il contenuto in 100B, sempre nel A.6, nel caso in cui inizialmente 100A contenesse 5
Scrivi un pezzo di assembler che sommi due numeri che si trovano in RAM agli indirizzi 3003 e 3004,
aggiunga 5 alla loro somma, e metta il risultato all’indirizzo 3005
∗
Scrivi un pezzo di assembler che, dati due numeri n e m, che si trovano in RAM agli indirizzi 100A
e 100B, calcoli nm , e lo scriva all’indirizzo 100C
4
2
Linguaggio Python
Gli esercizi sono all’incirca in ordine progressivo di difficoltà. Quelli contrassegnati con un asterisco
sono particolarmente difficili, il lettore non si preoccupi se non riesce a risolverli. Notare che, come
in generale nella programmazione, non vi è necessariamente una sola soluzione a un problema, quindi
negli esercizi in cui è richiesto di costruire una propria funzione, il risultato potrà anche essere differente
dalla soluzione indicata, senza per questo essere erroneo. La verifica può essere effettuata semplicemente
usando l’interprete Python.
P.1
Cosa risponde l’inteprete Python?
>>> 2 * ( ’ci’ + ’ao ’ )
P.2
Cosa risponde l’inteprete Python?
[ 3, ’si’ ] + [ ’no’, 2 ]
P.3
Avendo definito la variabile che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> ( 2 + 1 ) * ( [ 8 + 12 ] + [ ‘‘fo’’ + ‘‘rti’’ ] )
P.4
Avendo definito la variabile che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> l = [ 10, ’sole’, 1.3, ’A’, 1 ]
>>> l[ 1:4 ]
P.5
Avendo definito la variabile che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> s = ’evviva’
>>> s[ 1 ] + s[ 0 ]
P.6
Avendo definito la variabile che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> l = [ 10, ’luna’, [ ’sera’, ’alba’, ’giorno’ ], [ 2, 3 ], 21, 22 ]
>>> l[ 2 ][ 1:3 ]
P.7
Avendo definito la variabile che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> d = { ’giallo’ : [ ’oro’, ’sole’ ], ’rosso’ : [ ’fuoco’, ’rabbia’ ] }
>>> d[ ’giallo’ ][ -1 ]
P.8
∗
Avendo definito la variabile che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> d = { ’giallo’ : [ ’oro’, ’sole’ ], ’rosso’ : [ ’fuoco’, ’rabbia’ ] }
>>> d[ ’giallo’ ][ 0 ][ 0:2 ] + d[ ’rosso’ ][ 1 ][ 3:-1 ]
P.9
Avendo definito la funzione che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> def scambia( s ):
...
return s[ -1 ] + s[ 1 : -1 ]
...
>>> scambia ( "blu" )
+ s[ 0 ]
5
P.10
Avendo definito la funzione che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> def balbluz( s ):
...
return s[ 0:2 ] + s
...
>>> balbluz( "sai" )
P.11
Avendo definito la funzione che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> def pari( x ):
...
return x == 2 * ( x / 2 )
...
>>> [ pari( 4 ), pari( 3 ) ]
P.12
Avendo definito la funzione che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> def maschfemm( s ):
...
if s[ -1 ] == "o":
...
return s[ 0:-1 ] + "a"
...
if s[ -1 ] == "a":
...
return s[ 0:-1 ] + "o"
...
return s
...
>>> [ maschfemm( ’Carlo’ ), maschfemm( ’Angela’ ) ]
P.13
Avendo definito la funzione dell’esercizio P.12, cosa risponderà l’inteprete Python con questa istruzione?
map (maschfemm, [ ’caro’, ’amico’, ’bravo’, ’e’, ’bello’ ] )
P.14
Avendo definito la funzione che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> def somma( n ):
...
s
= 0
...
while n > 0:
...
s = s + n
...
n = n - 1
...
return s
...
>>> somma( 5 )
P.15
∗
Avendo definito la funzione che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> def conta( c, s ):
...
n
= 0
...
for l in s:
...
if c == l:
...
n = n + 1
...
return n
...
>>> conta( "b", "basta bere abbondantemente" )
6
P.16
∗
Avendo definito la funzione che segue, cosa risponderà l’inteprete Python nella successiva istruzione?
>>> def stringl( l ):
...
s
= ""
...
for w in l:
...
s = s + " " + w
...
return s
...
>>> stringl( [ ’tutto’, ’quello’, ’che’, ’vuoi’ ] )
P.17
Scrivi una funzione che produca il superlativo di un aggettivo dato, tenendo conto di maschile, femminile e plurali, ovvero che sia risultati di questo tipo:
>>> iss ( ’bella’ )
’bellissima’
>>> iss( ’brutti’ )
’bruttissimi’
>>> iss( ’cattivo’ )
’cattivissimo’
P.18
∗
Scrivi una funzione che produca il vezzeggiativo di un aggettivo dato, tenendo conto di maschile, femminile e plurali, tenendo conto della particolarità delle vocali finali, ovvero he riesca a dare
risultati di questo tipo:
>>> ucc( ’cara’ )
’caruccia’
>>> ucc( ’freddo’ )
’fredduccio’
>>> ucc( ’teneri’ )
’tenerucci’
>>> ucc( ’tiepide’ )
’tiepiducce’
P.19
∗
Riscrivi la funzione somma che effettua lo stesso calcolo di quella all’esercizio P.14, ma usando la
ricorsione.
7
Soluzioni degli esercizi
T.1
B
⇓
A
T.2
⇓
G
B
G
T.3
una x seguita da o:
T.4
Si ferma solo nel primo caso
⇓
vero/falso
···
x
···
o
vero/falso
vero/falso
STATO
INPUT
NUOVO
STATO
CASELLA
OUTPUT
0
0
1
1
2
3
4
5
falso
vero
falso
vero
-
1
2
3
4
4
5
5
-
⇒
⇒
⇒
⇒
⇒
-
falso
vero
-
T.5
STATO
INPUT
NUOVO
STATO
CASELLA
OUTPUT
0
0
1
1
2
2
3
M
F
M
F
M
F
-
0
1
0
2
0
3
-
⇒
⇒
⇒
⇒
⇒
-
F
F
F
-
STATO
INPUT
NUOVO
STATO
CASELLA
OUTPUT
0
0
1
1
2
2
3
4
5
6
7
0
1
0
1
0
1
-
1
2
7
3
5
0
4
0
6
0
-
⇒
⇒
⇐
⇐
⇒
⇒
⇒
⇒
-
1
0
0
1
-
T.6
T.7
RAM
CPU
R1
100
1000
mov $100A R1
1001
mov 20
1002
add R2 R1
1003
mov R1 $1007
R2
R2
20
....
R3
0
....
1006
343234
1007
100
1008
0
1009
400000
100A
80
100B
325
100C
67588567
1000
mov $100A R3
1001
mov −10
R2
1002
add −20
R3
1003
add R2
R3
mov R3 $100D
PC
1003
PS
A.1
RAM
CPU
R1
744
R2
−10
1006
R3
100
....
....
PC
1006
PS
100A
130
100B
0
100C
400000
100D
100
100E
325
100F
67588567
100E
mov $200F R2
100F
add R2
A.2
RAM
CPU
R1
0
mov R2 $200E
1011
add R2
mov R2 $200D
R2
16
1012
R3
10000
....
....
PC
PS
1012
R2
1010
R2
200A
130
200B
0
200C
400000
200D
16
200E
8
200F
4
A.3
8
A.4
10
A.5
Si, perché l’istruzione a 1003, mov R2 R3, non avendo risultato 0, spegne il bit Z del registro PS, e quindi la jumpz $1006 non avverrà
mai
A.6
10
A.7
35
RAM
CPU
1000
mov $3003 R1
1001
mov $3004 R2
1002
add R2 R1
1003
mov R1 $3005
R1
744
R2
820
....
R3
0
....
3003
343234
3004
10003
3005
0
PC
1000
PS
A.8
RAM
CPU
R1
mov
1001
mov
1002
mov
1
1003
mul
R2 R3
20
1004
add
−1 R1
3
....
1005
jmpz
$1007
1006
jmp
$1003
1007
mov
R3 $100C
10
R2
R3
PC
1000
1000
Z
PS 0 0 0 0 0 0 0 0 0 0
$100B R1
$100A R2
R3
1008
1009
100A
3
100B
4
100B
A.9
P.1
’ciao ciao ’
P.2
[3, ’si’, ’no’, 2]
P.3
[20, ’forti’, 20, ’forti’, 20, ’forti’]
P.4
[’sole’, 1.3, ’A’]
P.5
’ve’
P.6
[’alba’, ’giorno’]
P.7
’sole’
P.8
’orbi’
P.9
’ulb’
P.10
’sasai’
P.11
[True, False]
P.12
[’Carla’, ’Angelo’]
P.13
[’cara’, ’amica’, ’brava’, ’e’, ’bella’]
P.14
15
P.15
4
P.16
’ tutto quello che vuoi’
P.17
>>> def iss( p ):
...
return p[ 0 : -1 ] + ’issim’ + p[ -1 ]
...
9
P.18
>>> def ucc( p ):
...
if p[ -1 ] in [ ’i’, ’e’ ]:
...
return p[ 0 : -1 ] + ’ucc’ + p[ -1 ]
...
return p[ 0 : -1 ] + ’ucci’ + p[ -1 ]
...
P.19
>>> def somma( n ):
...
if n < 1:
...
return 0
...
return n + somma( n - 1 )
...
end
10