Ecrire un programme prenant en argument une valeur numérique positive n par la ligne de commande, et affichant un carré, une croix et un losange, tous de coté n. Par exemple, si n = 10, l’exécution donne
Saisissez la taille des figures
10
* * * * * * * * * *
* *
* *
* *
* *
* *
* *
* *
* *
* * * * * * * * * *
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
Vous définirez des sous-programmes de quelques lignes et au plus deux niveaux d’imbrication. Vous ferez attention à ne jamais écrire deux fois les mêmes instructions. Pour ce faire, complétez le code source suivant :
| #!/usr/bin/perl use strict; use warnings; use Carp (); local $SIG{__WARN__} = \&Carp::cluck; # affiche le caractère $c sub afficheCaractere# char $c { } # affiche $n fois le caractère $c # ne revient pas à la ligne après. sub ligneSansReturn# int $n, int $c { } # affiche $n fois le caractère $c # revient à la ligne après. sub ligneAvecReturn# int $n, int $c { } # affiche n espaces, revient à la ligne après. sub nEspaces# int $n { } # affiche $c à la colonne $n, affiche des espaces avant. # ne revient pas à la ligne après # les indices commencent à 1. sub unCaractereSansReturn# int $n, int $c { } # affiche $c à la colonne $n, affiche des espaces avant. # revient à la ligne après sub unCaractereAvecReturn# int $n, int $c { } # affiche $c aux colonnes $i et $j # revient à la ligne après. sub deuxCaracteres# int $i, int $j, char $c { } # affiche un carré de coté $n. sub carre# int $n { } # affiche un chapeau dont la pointe (non affichée) # est sur la colonne $centre en utilisant des $c. sub chapeau# int $centre, char $c. { } # affiche un chapeau retourné dont la pointe (non affichée) # est sur la colonne $centre en utilisant des $c. sub chapeauInverse# int $centre, char $c. { } # affiche un losange de coté $n. sub losange# int $n { } # affiche un losange de coté $n. sub croix# int $n { } carre $ARGV[0]; losange $ARGV[0]; croix $ARGV[0]; |
unites(n) retournant le chiffre
des unités du nombre n.
dizaines(n) retournant le
chiffre des dizaines du nombre n.
extrait(n, p) retourant le
p-ème chiffre de représentation décimale de n en partant des unités.
nbChiffres(n) retournant le
nombre de chiffres que comporte la représentation décimale de n.
sommeChiffres(n) retournant la
somme des chiffres de n.
Soient a et b deux entiers strictement positifs. a est un diviseur strict de b si a divise b et a ≠ b. Par exemple, 3 est un diviseur strict de 6. Mais 6 n’est pas un diviseur strict 6. a et b sont des nombres amis si la somme des diviseurs stricts de a est b et si la somme des diviseurs de b est a. Le plus petit couple de nombres amis connu est 220 et 284.
sommeDiviseursStricts(n), elle doit
renvoyer la somme des diviseurs stricts de n.
sontAmis(a, b), elle doit
renvoyer 1 si a et b sont amis, 0 sinon.
Un nombre parfait est un nombre égal à la somme de ses diviseurs stricts. Par exemple, 6 a pour diviseurs stricts 1, 2 et 3, comme 1 + 2 + 3 = 6, alors 6 est parfait.
estParfait(n), elle doit
retourner 1 si n est un nombre parfait, 0 sinon.
Un nombre n est un nombre de Kaprekar en base 10, si la représentation décimale de n2 peut être séparée en une partie gauche u et une partie droite v tel que u + v = n. 452 = 2025, comme 20 + 25 = 45, 45 est aussi un nombre de Kaprekar. 48792 = 23804641, comme 238 + 04641 = 4879 (le 0 de 046641 est inutile, je l’ai juste placé pour éviter toute confusion), alors 4879 est encore un nombre de Kaprekar.
sommeParties(n, p) qui
découpe n est deux nombres dont le deuxième comporte p chiffres,
et qui retourne leur somme. Par exemple,
| sommeParties(12540, 2) = 125 + 40 = 165 |
estKaprekar(n)
Ecrire une fonction
somme(t) retournant la
somme des éléments du tableau t (vous remarquerez que t peut aussi être
une liste de scalaires).
Ecrire une fonction
min(t) retournant la
valeur du plus petit élément de t.
Ecrire une fonction
existe(k, t)
retournant
vrai si et seulement si k
est un des éléments de T.
Ecrire une fonction
sommePairs(t),
retournant la somme
des éléments pairs de t. N’oubliez pas que
a%b est le reste de la division entière de a par b.
Ecrire une fonction
estTrie(t), estTrie(t) retournant vrai si et
seulement si les éléments de t sont triés dans l’ordre croissant.
Ecrire une fonction
permutation(t)
effectuant une permutation circulaire vers la droite des éléments de
t.
Ecrire une fonction
miroir(t inversant
l’ordre des éléments de t.
On rappelle qu’un nombre est premier s’il n’est divisible que par 1 et par lui-même. Par convention, 1 n’est pas premier.
Écrivez une fonction
estPremier(x, premiers)
retournant vrai si et seulement si x est premier. Vous vérifierez la
primarité de x en examinant les restes des divisions de x par les
éléments de premiers.
Modifiez la fonction précédente en tenant compte du fait que si aucun diviseur premier de x inférieur à √x n’a été trouvé, alors x est premier
Écrivez une fonction
trouvePremiers(n)
retournant un tableau contenant les n premiers nombres premiers.
Écrivez une fonction
decompose(x, premiers) prenant en paramètre un entier et
une référence vers un tableau.
decompose retourne une référence vers un tableau contenant
la décomposition en facteurs premiers
du nombre x, sachant que premiers contient les premiers nombres
premiers.
Par exemple, si x = 108108, alors on décompose n en produit de facteurs premiers de la sorte
| 108108 = 2*2*3*3*3*7*11*13 = 22*33*50*71*111*131*170*190* … *Z0 |
(où Z est le n-ième nombre premier). On représente donc x de façon unique par le tableau à n éléments suivant :
| {2, 3, 0, 1, 1, 1, 0, 0, 0, …, 0} |
Écrivez une fonction
recompose(decomposition, premiers)
effectuant l’opération réciproque de celle décrite ci-dessus.
Écrivez une fonction
pgcdTab(a, b)
prenant en paramètre les références des décompositions en facteurs
premiers a et b de deux nombres, et retournant une référence de
la décomposition en facteurs premiers du plus grand commun diviseur
de a et b.
Écrivez une fonction
pgcd(a, b) prenant en
paramètres deux nombres a et b, et combinant les fonctions
précédentes pour retourner le pgcd de a et b.