Recherche de nombres premiers.

Informatique_algorithmique
Projet_0 Nicolas et
Bousquet
But : - Recherche de nombres premiers.
- Méthodes de construction de carrés magiques et diaboliques.
- Tests pour vérifier le caractère magico-diabolique (MD) d’une
matrice.
- Tests pour savoir empiriquement pour quelle taille N les carrés
sont diaboliques.
Plan : - p1 - Plan + Introduction.
- p2 - Le crible d’Erathostène.
- p2-3 - Méthode par division.
- p3-4 - La construction de carrés magiques.
- p4-5 - La construction de carrés diaboliques.
- p5-7 - Tests du caractère MD.
- p7-9 - Test sur la taille N. (application du travail sur les nombres
premiers).
- p9-10 - Le menu.
- p10 - Conclusion.
Introduction :
Nous allons étudier dans un premier temps deux algorithmes de
recherche des nombres premiers : Le crible d’Erathostène et la méthode
par division des précédents nombres premiers.
Nous nous intéresserons ensuite aux méthodes de construction de
carrés magiques ou diaboliques ainsi qu’à l’élaboration de test servant à
vérifier si un carré est magique ou diabolique et dans quels cas
seulement il peut l’être. Les constructions des carrés se feront à l’aide
des matrices de matlab.
NB : algorithmes en matlab.

Le Crible d’Erathostène : (crible.m)
Le principe du crible :
Pour N entier donné, nous allons regardé, en partant de 1 et allant
jusqu’à N, si chacun des nombres est « barré » ou non. S’il n’est pas
barré alors c’est un nombre premier. En effet : initialisons un tableau de
N entiers (de 1 à N) et barrons 1 et 2 car il ne sont pas premiers,
l’algorithme va consister à barré tous les multiples de chaque nombre
premier rencontré (donc un nombre premier non barré) en partant de
l’entier 3 qui est premier. NB : on ne regarde que les nombres impairs, un
nombre pair ne pouvant pas être premier.
Le code correspondant au crible est :
function np=crible(n)
%--Crible d’Erathostène.
%--Input : un entier n positif supérieur à 3.
%--Output : le vecteur rempli de nombres premiers
% inférieur à n.
%--Remplissage du tableau de 1 à n :
for i=1:n
c(i)=i;
end
%--Initialisation:
np(1)=1;
np(2)=2;
l=2;
%--Boucle:
for k=3:2:n %--par pas de 2 : nombres impairs
if c(k)==k %--on regarde si le k-ème n’est
l=l+1; % pas “barré”, on incrémente l,
np(l)=k; % on écrit la valeur de k dans
for i=(3*k):k:n % le vecteur np, on met à zéros
c(i)=0; % (on “barre”) tout les multiples
end % de k.
end
end %--on écrit la valeur de np, qui
% contient les nombres premiers
% inférieur ou égal à N.

Méthode par division : (np.m)
Le principe de la méthode par division :
Pour N entier donné on va regarder, après avoir initialisé un vecteur
p (p(1)=1, p(2)=2, p(3)=3), si le nombre k (partant de 4 à N) est divisible
par tout les nombres premiers inférieurs à lui-même : s’il ne l’est pas
alors k est premier et est rajouté à la liste p des nombres premiers, sinon
on ne fait rien et on passe à k+1.
Le code correspondant est :
function np=np(n)
%--Affichage d’un vecteur contenant tout les nombres premiers
% de 3 à n.
%--Input : N entier strictement positif.
%--Output : le vecteur en question.
%--Initialisation :
np(1)=1;
np(2)=2;
np(3)=3;
l=3;
%--Boucle :
for k=5:2:n %--de 5 à n par pas de 2 on ne
d=0; % regarde que les nombres
for i=3:l % impairs.
if (mod(k,np(i)))==0 %--critère de divisibilité.
d=1;
break
end
end
if d==0
l=l+1; %--incrémentation de l et
np(l)=k; % écriture de k à la l-ème
end % place.
End %--écriture du vecteur np.
Construction de carrés magiques : (magic.m)
Une des méthodes de construction que nous allons utiliser est
seulement valable au cas N entier naturel impair.
Algorithme de construction :
Pour un carré de taille N on remplit préalablement notre matrice de
zéros (N² zéros) puis on se place à la (N+1)/2 ème ligne et (N+3)/2 ème
colonne et on écrit 1. Supposons maintenant que nous soyons à l’étape k,
ayant écrit la (k-1)-ème valeur dans la case adaptée. A l’étape suivante
nous allons décrémenter i (indice de ligne) et incrémenter j (indice de
colonne) et regarder si la case contient un zéro : si oui on écrit la valeur
suivante k, sinon on incrémente i et incrémente j encore une fois et on
écrit la valeur k à la nouvelle case obtenue. L’algorithme se poursuit

alors. Si un déplacement de ligne ou de colonne est nécessaire on se
place à la ligne ou colonne opposée correspondante (comme si l’espace
était torique).
Le code correspondant est :
function A=magic(n)
%--Carré magique avec un nombre impaire.
%--Input : un entier positif impair.
%--Output : la matrice magique de taille N.
%--Test sur la parité de n :
if mod(n,2)==0
error('n pas impaire');
end
%--Initialisation :
A=zeros(n);
i=(n+1)/2;
j=(n+3)/2;
A(i,j)=1;
%--Boucle de remplissage :
for k=2:n^2
i=i-1;
test=0;
if i==0
i=n;
end
while ~test
j=j+1;
if j==n+1
j=1;
end
if A(i,j)==0
test=1;
else
i=i+1;
if i==n+1
i=1;
end
end
end
A(i,j)=k; %--Affectation de la valeur.
end
Construction de carrés diaboliques : (diabolic.m)
On demande à l’utilisateur de rentrez un entier positif N. Nous
verrons par la suite quels sont les N qui permettent de construire un
carré diabolique.
Algorithme de construction :

On applique la méthode du cavalier. Je remplis préalablement ma
matrice de zéros. Je place mon 1 de départ dans n’importe quel case de la
matrice. Supposons que je me trouve à la k+1-ème valeur et que je viens
de placer la k-ème à la case de coordonnée (i,j), alors si k n’est pas
multiple de N le mouvement du cavalier impose une décrémentation de i
de 2 (i :=i-2 ) et une incrémentation simple de j, sinon je ne fais
qu’incrémenter i et je place la valeur k+1 à cette nouvelle case. On
continue jusqu’à remplir complètement la matrice.
Le code correspondant est :
function A=diabolic(n,i,j)
%--Carré diabolique de n sur n en partant de la case (i,j).
%--Input : n=dimension , (i,j)=coordonées de départ.
%--Output : carré diabolique.
%--Initialisation :
A(i,j)=1;
%--Cas d’erreurs :
if (i>n)|(i<=0)|(j>n)|(j<=0)
error('i et j pas compris dans la dimension ')
end
if (n<=0)
error('n doit etre positif')
end
%--Boucle de remplissage :
for k=2:(n^2)
if mod(k-1,n)==0
i=i+1;
if i==n+1
i=1;
end
else
i=i-2;
if i<=0
i=n+i;
end
j=j+1;
if j==n+1
j=1;
end
end
A(i,j)=k;
end
Cette méthode ne marche correctement que pour certaines valeurs de N.
(voir Test sur la taille N p7).
Test du caractère MD : (testdiabolic.m)
Dans cet algorithme nous allons vérifier si une matrice donnée est,
déjà, magique et ensuite si elle est diabolique. Pour ce faire nous allons
comparer différentes sommes à une valeur de référence qui peut être la