1° Un tableau T à n lignes et p colonnes étant donné , écrire une procédure

ligne( T , p , i ) qui calcule la somme des éléments de T situés en ligne i .

2° Un tableau T à n lignes et p colonnes étant donné , écrire une procédure

colonne( T , n , j ) qui calcule la somme des éléments de T situés en colonne j .

3° Un tableau carré T à n lignes et n colonnes étant donné , écrire une procédure

diagonale1( T , n ) qui calcule la somme des éléments de T situés sur la première diagonale.

4° Un tableau carré T à n lignes et n colonnes étant donné , écrire une procédure

diagonale2( T , n ) qui calcule la somme des éléments de T situés sur la seconde diagonale.

5° Un tableau T carré à n lignes et n colonnes est dit magique si la somme des éléments de

n'importe quelle ligne , de n'importe quelle colonne , et de n'importe quelle diagonale est

la même .

Utiliser les procédures précédentes pour écrire une fonction booléenne magique( T , n )

rendant la valeur true si T est magique, et false sinon .

Exemples:

> magique(T,3);

> magique(U,3);

Ecrire la procédure intitulée coder(st::string) qui convertit la chaîne de caractères st

(écrite en lettres minuscules) en un nombre.

On code : , , etc ... , .

Exemple: si alors , , 6 , , .

> coder("maple");

Aide: pour écrire cette procédure , on construira un alphabet puis une table T de conversion

et on utilisera au besoin les fonctions de Maple suivantes:

length(st) qui donne la longueur de la chaîne de caractères st .

substring(st,m..n) qui extrait de st la sous-chaîne des caractères situés entre les

positions m et n.

> T:=array([[4,1,2],[3,5,6],[7,9,2]]):

> ligne:=proc(T::array,p::posint,i::posint)

> local j,s;

> s:=0:

> for j to p do

> s:=s+T[i,j]

> od;

> end;

> print(T);for i to 3 do ligne(T,3,i) od;

> colonne:=proc(T::array,n::posint,j::posint)

> local i,s;

> s:=0:

> for i to n do

> s:=s+T[i,j]

> od;

> end;

> print(T);for j to 3 do colonne(T,3,j) od;

> diagonale1:=proc(T::array,n::posint)

> local i,s;

> s:=0:

> for i to n do

> s:=s+T[i,i]

> od;

> end;

> print(T);diagonale1(T,3);

> diagonale2:=proc(T::array,n::posint)

> local i,s;

> s:=0:

> for i to n do

> s:=s+T[i,n+1-i]

> od;

> end;

> print(T);diagonale2(T,3);

> magique:=proc(T::array,n::posint)

> local s,i,j;

> s:=diagonale1(T,n):

> if diagonale2(T,n)<>s then RETURN(false) fi;

> for i to n do

> if ligne(T,n,i)<>s then RETURN(false) fi

> od;

> for j to n do

> if colonne(T,n,j)<>s then RETURN(false) fi

> od;

> RETURN(true);

> end;

> magique(T,3);

> T:=array([[8,1,6],[3,5,7],[4,9,2]]);

> magique(T,3);

Création de l'alphabet:

> restart:alphabet:=["a","b","c","d","e","f","g","h","i","j","k","l","m",
                                      "n","o","p","q","r","s","t","u","v","w","x","y","z"];

Création d'une table T de conversion lettres --> nombres:

> for K to nops(alphabet) do T[alphabet[K]]:=K end do:

Procédure de codage :

> coder:=proc(st::string)
        local J,K,L,N,S;
            L:=length(st);
            if L= 0 then error "chaine vide" end if;
            N:=0;K:=1;
            for J from L by -1 to 1 do
                S:=substring(st,J..J):
                if not member(S,alphabet) then error "mauvais caractère " || S end if;
                N:=K*T[S]+N;
                K:=K*100;
            end do;
            N;
    end proc;

> coder("maple");