1 - Cedric

Sûreté de la programmation orientée objets
(NFP101)
Programmes impératifs ou fonctionnels ?
Motivation
1. Vérifiez que la fonction Scala suivante compile, et testez-la dans l'interpréteur (cet
exemple est tiré de Scala By Example de Martin Odersky).
def sort (xs: Array[Int ]) {
def swap(i : Int , j : Int ) {
val t = xs(i ); xs(i ) = xs(j ); xs(j ) = t
}
def sort1 (l : Int , r : Int ) {
val pivot = xs((l + r ) / 2)
var i = l ; var j = r
while (i <= j ) {
while (xs(i ) < pivot ) i += 1
while (xs(j ) > pivot) j -= 1
if (i <= j ) {
swap(i , j )
i += 1
j -= 1
}
}
if (l < j ) sort1 (l , j )
if (j < r ) sort1 (i , r )
}
sort1 (0, xs.length - 1)
}
2. Même question pour la fonction suivante :
def sort (xs: Array[Int]): Array[Int ] = {
if (xs.length <= 1) xs
else {
val pivot = xs(xs.length / 2)
Array.concat (
sort(xs.lter (x => pivot > x )),
xs.lter (x => pivot == x ),
sort(xs.lter (x => pivot < x )))
}
}
3. Vériez que le tableau donné en argument n'est pas modié.
4. Remplacer Array par Vector (tableaux immutables ou persistants) dans l'exemple précédent et tester à nouveau.
5. Remplacer Array par List (listes immutables ou persistantes) dans le même exemple et
tester à nouveau.
1
Types simples
1. Donner les types et les valeurs des expressions suivantes (la fonction length renvoie la
longueur d'une liste ou d'une chaîne de caractères) :
("two", true, 'y');
List(("two", true, 2));
((1, 2), List(3, 4, 5).length);
(List(1, 2), List(3, 4, 5));
List(List(), List(0), List());
("andrew", "andrew".length);
(List("andrew" == "andrew", "andrew" == "ben"), "andrew".length);
2. Considérer les déclarations suivantes. Sont-elles correctes ? Pour celles qui sont correctes,
quelles sont les variables dénies, leur types et leur valeurs ?
val
val
val
val
a =
(c,
(e,
(l,
(5, 6);
d) = (2, ("xx", "yy"));
(f, g)) = (1, (2, 3));
m, n) = ("xx", (1, 2));
3. Même question pour les déclarations suivantes :
val
val
val
val
(p,
(_,
(r,
(r,
_)
_)
r)
r)
=
=
=
=
(12,
(12,
(12,
(12,
10);
10);
10);
12);
val u = List(1, 2, 3);
val w = 1::List(2, 3);
val t = List(4) ++ List(5, 6);
4. Donner le type des fonctions suivantes :
def
def
def
def
fone (x: Int) = List(x, x, x);
ftwo (x: Int) = (x, x, x);
fthree (x: String, y: Int) = List((x ++ "b", y + 1));
ffour (x: Int, y: String, z: Int) = (x + y.length, x + z);
5. Voici une dénition de la fonction double :
def double(x: Int) = 2 * x;
Dénir de manière semblable la fonction triple. La fonction times4 peut être dénie en
appliquant double deux fois :
def times4(x: Int) = double(double(x));
Dénir times9 et times6 de la même manière.
6. Définir une fonction duplicate telle que dupliquate("go") renvoie "gogo". Définir
ensuite de même les fonctions quadricate, octicate and hexadecicate.
7. La méthode substring est prédénie. Elle prend en entrée l'indice de début et l'indice de
n (premier caractère exclu) et renvoie la sous-chaîne correspondante. Par exemple, on
peut dénir une fonction clip qui enlève le dernier caractère d'une chaîne ainsi :
def clip(s: String) = s.substring(0, s.length - 1);
Dénir des fonctions middle, dtrunc, switch et dubmid qui vérient :
middle("badge") == "d"
dtrunc("trouser") == "rouse"
switch("overhang") == "hangover"
dubmid("below") == "bellow"
middle("eye") ==
dtrunc("plucky")
switch("selves")
dubmid("son") ==
2
"y"
== "luck"
== "vessel"
"soon"